home *** CD-ROM | disk | FTP | other *** search
/ PC World 2007 March / PCWorld_2007-03_cd.bin / domacnost a kancelar / scribus / scribus-1.3.3.7-win32-install.exe / share / plugins / barcode.ps next >
Text File  |  2006-11-27  |  118KB  |  3,564 lines
  1. %!PS-Adobe-2.0
  2. %%Creator: Terry Burton
  3. %%DocumentPaperSizes: a4
  4. %%EndComments
  5. %%EndProlog
  6.  
  7. % Barcode Writer in Pure PostScript - Version 2006-09-26
  8. % http://www.terryburton.co.uk/barcodewriter/
  9. %
  10. % Copyright (c) 2006 Terry Burton - tez@terryburton.co.uk
  11. %
  12. % Permission is hereby granted, free of charge, to any
  13. % person obtaining a copy of this software and associated
  14. % documentation files (the "Software"), to deal in the
  15. % Software without restriction, including without
  16. % limitation the rights to use, copy, modify, merge,
  17. % publish, distribute, sublicense, and/or sell copies of
  18. % the Software, and to permit persons to whom the Software
  19. % is furnished to do so, subject to the following
  20. % conditions:
  21. %
  22. % The above copyright notice and this permission notice
  23. % shall be included in all copies or substantial portions
  24. % of the Software.
  25. %
  26. % THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
  27. % KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  28. % THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  29. % PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  30. % THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  31. % DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
  32. % CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  33. % CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  34. % IN THE SOFTWARE.
  35.  
  36. % Uncomment this next line to allow these procedure definitions to 
  37. % remain resident within a printer's PostScript virtual machine 
  38. % so that the barcode generation capability persists between jobs.
  39.  
  40. % serverdict begin 0 exitserver 
  41.  
  42. % --BEGIN TEMPLATE--
  43.  
  44. % --BEGIN ENCODER ean13--
  45. % --DESC: EAN-13
  46. % --EXAM: 977147396801
  47. /ean13 {
  48.  
  49.     0 begin
  50.  
  51.     /options exch def                  % We are given an option string
  52.     /useropts options def
  53.     /barcode exch def                  % We are given a barcode string
  54.  
  55.     /includetext false def             % Enable/disable text
  56.     /textfont /Helvetica def
  57.     /textsize 12 def
  58.     /textpos -4 def
  59.     /height 1 def
  60.     
  61.     % Parse the input options
  62.     options {
  63.         token false eq {exit} if dup length string cvs (=) search
  64.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  65.     } loop
  66.     
  67.     /textfont textfont cvlit def
  68.     /textsize textsize cvr def
  69.     /textpos textpos cvr def
  70.     /height height cvr def
  71.     
  72.     /barlen barcode length def         % Length of the code
  73.  
  74.     % Add checksum digit to barcode if length is even
  75.     barlen 2 mod 0 eq {
  76.         /pad barlen 1 add string def   % Create pad one bigger than barcode
  77.         /checksum 0 def
  78.         0 1 barlen 1 sub {
  79.             /i exch def
  80.             /barchar barcode i get 48 sub def
  81.             i 2 mod 0 eq {
  82.                 /checksum barchar checksum add def
  83.             } {
  84.                 /checksum barchar 3 mul checksum add def
  85.             } ifelse
  86.         } for
  87.         /checksum 10 checksum 10 mod sub 10 mod def
  88.         pad 0 barcode putinterval       % Add barcode to the start of the pad
  89.         pad barlen checksum 48 add put  % Put ascii for checksum at end of pad
  90.         /barcode pad def                % barcode=pad
  91.         /barlen barlen 1 add def        % barlen++
  92.     } if
  93.  
  94.     % Create an array containing the character mappings
  95.     /encs
  96.     [ (3211) (2221) (2122) (1411) (1132)
  97.       (1231) (1114) (1312) (1213) (3112)
  98.       (111) (11111) (111)
  99.     ] def
  100.  
  101.     % Create a string of the available characters
  102.     /barchars (0123456789) def
  103.  
  104.     % Digits to mirror on left side
  105.     /mirrormaps
  106.     [ (000000) (001011) (001101) (001110) (010011)
  107.       (011001) (011100) (010101) (010110) (011010)
  108.     ] def
  109.  
  110.     /sbs barlen 1 sub 4 mul 11 add string def
  111.     /txt barlen array def
  112.   
  113.     % Put the start character
  114.     sbs 0 encs 10 get putinterval
  115.  
  116.     % First digit - determine mirrormap by this and show before guard bars
  117.     /mirrormap mirrormaps barcode 0 get 48 sub get def
  118.     txt 0 [barcode 0 1 getinterval -10 textpos textfont textsize] put
  119.  
  120.     % Left side - performs mirroring
  121.     1 1 6 {
  122.         % Lookup the encoding for the each barcode character
  123.         /i exch def
  124.         barcode i 1 getinterval barchars exch search
  125.         pop                            % Discard true leaving pre
  126.         length /indx exch def          % indx is the length of pre
  127.         pop pop                        % Discard seek and post
  128.         /enc encs indx get def         % Get the indxth encoding
  129.         mirrormap i 1 sub get 49 eq {   % Reverse enc if 1 in this position in mirrormap
  130.             /enclen enc length def
  131.             /revenc enclen string def
  132.             0 1 enclen 1 sub {
  133.                 /j exch def
  134.                 /char enc j get def
  135.                 revenc enclen j sub 1 sub char put
  136.             } for
  137.             /enc revenc def
  138.         } if
  139.         sbs i 1 sub 4 mul 3 add enc putinterval   % Put encoded digit into sbs
  140.         txt i [barcode i 1 getinterval i 1 sub 7 mul 4 add textpos textfont textsize] put
  141.     } for
  142.  
  143.     % Put the middle character
  144.     sbs 7 1 sub 4 mul 3 add encs 11 get putinterval
  145.  
  146.     % Right side
  147.     7 1 12 {
  148.         % Lookup the encoding for the each barcode character
  149.         /i exch def
  150.         barcode i 1 getinterval barchars exch search
  151.         pop                            % Discard true leaving pre
  152.         length /indx exch def          % indx is the length of pre
  153.         pop pop                        % Discard seek and post
  154.         /enc encs indx get def         % Get the indxth encoding
  155.         sbs i 1 sub 4 mul 8 add enc putinterval  % Put encoded digit into sbs
  156.         txt i [barcode i 1 getinterval i 1 sub 7 mul 8 add textpos textfont textsize] put
  157.     } for
  158.  
  159.     % Put the end character
  160.     sbs barlen 1 sub 4 mul 8 add encs 12 get putinterval
  161.     
  162.     % Return the arguments
  163.     /retval 4 dict def
  164.     retval (sbs) [sbs {48 sub} forall] put
  165.     includetext {
  166.         retval (bhs) [height height 12{height .075 sub}repeat height height 12{height .075 sub}repeat height height] put
  167.         retval (bbs) [0 0 12{.075}repeat 0 0 12{.075}repeat 0 0] put
  168.         retval (txt) txt put
  169.     } {
  170.         retval (bhs) [30{height}repeat] put        
  171.         retval (bbs) [30{0}repeat] put
  172.     } ifelse
  173.     retval (opt) useropts put
  174.     retval (guardrightpos) 10 put
  175.     retval (borderbottom) 5 put
  176.     retval
  177.     
  178.     end
  179.  
  180. } bind def
  181. /ean13 load 0 1 dict put
  182. % --END ENCODER ean13--
  183.  
  184. % --BEGIN ENCODER ean8--
  185. % --DESC: EAN-8
  186. % --EXAM: 01335583
  187. /ean8 {
  188.  
  189.     0 begin
  190.  
  191.     /options exch def                  % We are given an option string
  192.     /useropts options def
  193.     /barcode exch def                  % We are given a barcode string
  194.  
  195.     /includetext false def              % Enable/disable text
  196.     /textfont /Helvetica def
  197.     /textsize 12 def
  198.     /textpos -4 def
  199.     /height 1 def
  200.     
  201.     % Parse the input options
  202.     options {
  203.         token false eq {exit} if dup length string cvs (=) search
  204.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  205.     } loop
  206.     
  207.     /textfont textfont cvlit def
  208.     /textsize textsize cvr def
  209.     /textpos textpos cvr def
  210.     /height height cvr def
  211.     
  212.     % Create an array containing the character mappings
  213.     /encs
  214.     [ (3211) (2221) (2122) (1411) (1132)
  215.       (1231) (1114) (1312) (1213) (3112)
  216.       (111) (11111) (111)
  217.     ] def
  218.  
  219.     % Create a string of the available characters
  220.     /barchars (0123456789) def
  221.  
  222.     /barlen barcode length def           % Length of the code
  223.     /sbs barlen 4 mul 11 add string def
  224.     /txt barlen array def
  225.     
  226.     % Put the start character
  227.     sbs 0 encs 10 get putinterval
  228.  
  229.     % Left side
  230.     0 1 3 {
  231.         % Lookup the encoding for the each barcode character
  232.         /i exch def
  233.         barcode i 1 getinterval barchars exch search
  234.         pop                                % Discard true leaving pre
  235.         length /indx exch def              % indx is the length of pre
  236.         pop pop                            % Discard seek and post
  237.         /enc encs indx get def             % Get the indxth encoding
  238.         sbs i 4 mul 3 add enc putinterval  % Put encoded digit into sbs
  239.         txt i [barcode i 1 getinterval i 7 mul 4 add textpos textfont textsize] put
  240.     } for
  241.  
  242.     % Put the middle character
  243.     sbs 4 4 mul 3 add encs 11 get putinterval
  244.  
  245.     % Right side
  246.     4 1 7 {
  247.         % Lookup the encoding for the each barcode character
  248.         /i exch def
  249.         barcode i 1 getinterval barchars exch search
  250.         pop                                % Discard true leaving pre
  251.         length /indx exch def              % indx is the length of pre
  252.         pop pop                            % Discard seek and post
  253.         /enc encs indx get def             % Get the indxth encoding
  254.         sbs i 4 mul 8 add enc putinterval  % Put encoded digit into sbs
  255.         txt i [barcode i 1 getinterval i 7 mul 8 add textpos textfont textsize] put
  256.     } for
  257.  
  258.     % Put the end character
  259.     sbs barlen 4 mul 8 add encs 12 get putinterval
  260.  
  261.     % Return the arguments
  262.     /retval 4 dict def
  263.     retval (sbs) [sbs {48 sub} forall] put
  264.     includetext {
  265.         retval (bhs) [height height 8{height .075 sub}repeat height height 8{height .075 sub}repeat height height] put
  266.         retval (bbs) [0 0 8{.075}repeat 0 0 8{.075}repeat 0 0] put
  267.         retval (txt) txt put
  268.     } {
  269.         retval (bhs) [22{height}repeat] put        
  270.         retval (bbs) [22{0}repeat] put
  271.     } ifelse
  272.     retval (opt) useropts put
  273.     retval (guardleftpos) 10 put
  274.     retval (guardrightpos) 10 put
  275.     retval (borderbottom) 5 put
  276.     retval
  277.  
  278.     end
  279.  
  280. } bind def
  281. /ean8 load 0 1 dict put
  282. % --END ENCODER ean8--
  283.  
  284. % --BEGIN ENCODER upca--
  285. % --DESC: UPC-A
  286. % --EXAM: 78858101497
  287. /upca {
  288.  
  289.     0 begin
  290.  
  291.     /options exch def
  292.     /useropts options def
  293.     /barcode exch def             % We are given a barcode string
  294.  
  295.     /includetext false def         % Enable/disable text
  296.     /textfont /Helvetica def
  297.     /textsize 12 def
  298.     /textpos -4 def
  299.     /height 1 def
  300.     
  301.     % Parse the input options
  302.     options {
  303.         token false eq {exit} if dup length string cvs (=) search
  304.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  305.     } loop
  306.     
  307.     /textfont textfont cvlit def
  308.     /textsize textsize cvr def
  309.     /textpos textpos cvr def
  310.     /height height cvr def
  311.     
  312.     /barlen barcode length def         % Length of the code
  313.  
  314.     % Add checksum digit to barcode if length is odd
  315.     barlen 2 mod 0 ne {
  316.         /pad barlen 1 add string def   % Create pad one bigger than barcode
  317.         /checksum 0 def
  318.         0 1 barlen 1 sub {
  319.            /i exch def
  320.            /barchar barcode i get 48 sub def
  321.            i 2 mod 0 ne {
  322.                /checksum checksum barchar add def
  323.            } {
  324.                /checksum checksum barchar 3 mul add def
  325.            } ifelse
  326.         } for
  327.         /checksum 10 checksum 10 mod sub 10 mod def
  328.         pad 0 barcode putinterval       % Add barcode to the start of the pad
  329.         pad barlen checksum 48 add put  % Put ascii for checksum at end of pad
  330.         /barcode pad def                % barcode=pad
  331.         /barlen barlen 1 add def        % barlen++
  332.     } if
  333.  
  334.     % Create an array containing the character mappings
  335.     /encs
  336.     [ (3211) (2221) (2122) (1411) (1132)
  337.       (1231) (1114) (1312) (1213) (3112)
  338.       (111) (11111) (111)
  339.     ] def
  340.  
  341.     % Create a string of the available characters
  342.     /barchars (0123456789) def
  343.  
  344.     /sbs barlen 4 mul 11 add string def
  345.     /txt barlen array def
  346.  
  347.     % Put the start character
  348.     sbs 0 encs 10 get putinterval
  349.  
  350.     % Left side
  351.     0 1 5 {
  352.         % Lookup the encoding for the each barcode character
  353.         /i exch def
  354.         barcode i 1 getinterval barchars exch search
  355.         pop                                % Discard true leaving pre
  356.         length /indx exch def              % indx is the length of pre
  357.         pop pop                            % Discard seek and post
  358.         /enc encs indx get def             % Get the indxth encoding
  359.         sbs i 4 mul 3 add enc putinterval  % Put encoded digit into sbs
  360.         i 0 eq {      % First digit is before the guard bars
  361.             txt 0 [barcode 0 1 getinterval -7 textpos textfont textsize 2 sub] put
  362.         } {
  363.             txt i [barcode i 1 getinterval i 7 mul 4 add textpos textfont textsize] put
  364.         } ifelse
  365.     } for
  366.  
  367.     % Put the middle character
  368.     sbs 6 4 mul 3 add encs 11 get putinterval
  369.  
  370.     % Right side
  371.     6 1 11 {
  372.         % Lookup the encoding for the each barcode character
  373.         /i exch def
  374.         barcode i 1 getinterval barchars exch search
  375.         pop                                % Discard true leaving pre
  376.         length /indx exch def              % indx is the length of pre
  377.         pop pop                            % Discard seek and post
  378.         /enc encs indx get def             % Get the indxth encoding
  379.         sbs i 4 mul 8 add enc putinterval  % Put encoded digit into sbs
  380.         i 11 eq {       % Last digit is after guard bars
  381.             txt 11 [barcode 11 1 getinterval 96 textpos textfont textsize 2 sub] put
  382.         } {
  383.             txt i [barcode i 1 getinterval i 7 mul 8 add textpos textfont textsize] put
  384.         } ifelse
  385.     } for
  386.  
  387.     % Put the end character
  388.     sbs barlen 4 mul 8 add encs 12 get putinterval
  389.  
  390.     % Return the arguments
  391.     /retval 4 dict def
  392.     retval (sbs) [sbs {48 sub} forall] put
  393.     includetext {
  394.         retval (bhs) [4{height}repeat 10{height .075 sub}repeat height height 10{height .075 sub}repeat 5{height}repeat] put      
  395.         retval (bbs) [0 0 0 0 10{.075}repeat 0 0 10{.075}repeat 0 0 0 0 0] put
  396.         retval (txt) txt put
  397.     } {
  398.         retval (bhs) [31{height}repeat] put
  399.         retval (bbs) [31{0}repeat] put
  400.     } ifelse
  401.     retval (opt) useropts put
  402.     retval (borderbottom) 5 put
  403.     retval
  404.  
  405.     end
  406.  
  407. } bind def
  408. /upca load 0 1 dict put
  409. % --END ENCODER upca--
  410.  
  411. % --BEGIN ENCODER upce--
  412. % --DESC: UPC-E
  413. % --EXAM: 0123456
  414. /upce {
  415.  
  416.     0 begin
  417.  
  418.     /options exch def                   % We are given an option string
  419.     /useropts options def
  420.     /barcode exch def                   % We are given a barcode string
  421.  
  422.     /includetext false def               % Enable/disable text
  423.     /textfont /Helvetica def
  424.     /textsize 12 def
  425.     /textpos -4 def
  426.     /height 1 def
  427.     
  428.     % Parse the input options
  429.     options {
  430.         token false eq {exit} if dup length string cvs (=) search
  431.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  432.     } loop
  433.     
  434.     /textfont textfont cvlit def
  435.     /textsize textsize cvr def
  436.     /textpos textpos cvr def
  437.     /height height cvr def
  438.     
  439.     /barlen barcode length def          % Length of the code
  440.  
  441.     % Create an array containing the character mappings
  442.     /encs
  443.     [ (3211) (2221) (2122) (1411) (1132)
  444.       (1231) (1114) (1312) (1213) (3112)
  445.       (111) (1111111)
  446.     ] def
  447.  
  448.     % Create a string of the available characters
  449.     /barchars (0123456789) def
  450.  
  451.     /mirrormaps
  452.     [ (000111) (001011) (001101) (001110) (010011)
  453.       (011001) (011100) (010101) (010110) (011010)
  454.     ] def
  455.  
  456.     % Add checksum digit to barcode if length is odd
  457.     barlen 2 mod 0 ne {
  458.         /pad barlen 1 add string def    % Create pad one bigger than barcode
  459.         /checksum 0 def
  460.         0 1 barlen 1 sub {
  461.             /i exch def
  462.             /barchar barcode i get 48 sub def
  463.             i 2 mod 0 ne {
  464.                 /checksum barchar checksum add def
  465.             } {
  466.                 /checksum barchar 3 mul checksum add def
  467.             } ifelse
  468.         } for
  469.         /checksum 10 checksum 10 mod sub 10 mod def
  470.         pad 0 barcode putinterval       % Add barcode to the start of the pad
  471.         pad barlen checksum 48 add put  % Put ascii for checksum at end of pad
  472.         /barcode pad def                % barcode=pad
  473.         /barlen barlen 1 add def        % barlen++
  474.     } if
  475.     /txt barlen array def
  476.     txt 0 [barcode 0 1 getinterval -7 textpos textfont textsize 2 sub] put
  477.  
  478.     % Determine the mirror map based on checksum
  479.     /mirrormap mirrormaps barcode barlen 1 sub get 48 sub get def
  480.  
  481.     % Invert the mirrormap if we are using a non-zero number system
  482.     barcode 0 get 48 eq {
  483.         /invt mirrormap length string def
  484.         0 1 mirrormap length 1 sub {
  485.             /i exch def
  486.             mirrormap i get 48 eq {
  487.                 invt i 49 put
  488.             } {
  489.                 invt i 48 put
  490.             } ifelse
  491.         } for
  492.         /mirrormap invt def
  493.     } if
  494.  
  495.     /sbs barlen 2 sub 4 mul 10 add string def
  496.  
  497.     % Put the start character
  498.     sbs 0 encs 10 get putinterval
  499.  
  500.     1 1 6 {
  501.         /i exch def
  502.         % Lookup the encoding for the each barcode character
  503.         barcode i 1 getinterval barchars exch search
  504.         pop                            % Discard true leaving pre
  505.         length /indx exch def          % indx is the length of pre
  506.         pop pop                        % Discard seek and post
  507.         /enc encs indx get def         % Get the indxth encoding
  508.         mirrormap i 1 sub get 49 eq {  % Reverse enc if 1 in this position in mirrormap        
  509.             /enclen enc length def
  510.             /revenc enclen string def
  511.             0 1 enclen 1 sub {
  512.                 /j exch def
  513.                 /char enc j get def
  514.                 revenc enclen j sub 1 sub char put
  515.             } for
  516.             /enc revenc def
  517.         } if
  518.         sbs i 1 sub 4 mul 3 add enc putinterval   % Put encoded digit into sbs
  519.         txt i [barcode i 1 getinterval i 1 sub 7 mul 4 add textpos textfont textsize] put
  520.     } for
  521.  
  522.     txt 7 [barcode 7 1 getinterval 6 7 mul 11 add textpos textfont textsize 2 sub] put
  523.  
  524.     % Put the end character
  525.     sbs barlen 2 sub 4 mul 3 add encs 11 get putinterval
  526.  
  527.     % Return the arguments
  528.     /retval 4 dict def
  529.     retval (sbs) [sbs {48 sub} forall] put
  530.     includetext {
  531.         retval (bhs) [height height 12{height .075 sub}repeat height height height] put      
  532.         retval (bbs) [0 0 12{.075}repeat 0 0 0] put    
  533.         retval (txt) txt put
  534.     } {
  535.         retval (bhs) [17{height}repeat] put      
  536.         retval (bbs) [17{0}repeat] put    
  537.     } ifelse
  538.     retval (opt) useropts put
  539.     retval (borderbottom) 5 put
  540.     retval
  541.  
  542.     end
  543.  
  544. } bind def
  545. /upce load 0 1 dict put
  546. % --END ENCODER upce--
  547.  
  548. % --BEGIN ENCODER ean5--
  549. % --DESC: EAN-5 (5 digit addon)
  550. % --EXAM: 0123456
  551. /ean5 {
  552.  
  553.     0 begin
  554.  
  555.     /options exch def                   % We are given an option string
  556.     /useropts options def
  557.     /barcode exch def                   % We are given a barcode string
  558.  
  559.     /includetext false def              % Enable/disable text
  560.     /textfont /Helvetica def
  561.     /textsize 12 def
  562.     /textpos (unset) def
  563.     /height 0.7 def    
  564.     
  565.     % Parse the input options
  566.     options {
  567.         token false eq {exit} if dup length string cvs (=) search
  568.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  569.     } loop
  570.     
  571.     /textfont textfont cvlit def
  572.     /textsize textsize cvr def
  573.     /height height cvr def
  574.     textpos (unset) eq {
  575.         /textpos height 72 mul 1 add def
  576.     } {
  577.         /textpos textpos cvr def
  578.     } ifelse
  579.     
  580.     /barlen barcode length def          % Length of the code
  581.  
  582.     % Create an array containing the character mappings
  583.     /encs
  584.     [ (3211) (2221) (2122) (1411) (1132)
  585.       (1231) (1114) (1312) (1213) (3112)
  586.       (112) (11)
  587.     ] def
  588.  
  589.     % Create a string of the available characters
  590.     /barchars (0123456789) def
  591.  
  592.     % Determine the mirror map based on mod 10 checksum
  593.     /mirrormaps
  594.     [ (11000) (10100) (10010) (10001) (01100)
  595.       (00110) (00011) (01010) (01001) (00101)
  596.     ] def
  597.     /checksum 0 def
  598.     0 1 4 {
  599.         /i exch def
  600.         /barchar barcode i get 48 sub def
  601.         i 2 mod 0 eq {
  602.             /checksum barchar 3 mul checksum add def
  603.         } {
  604.             /checksum barchar 9 mul checksum add def
  605.         } ifelse
  606.     } for
  607.     /checksum checksum 10 mod def
  608.     /mirrormap mirrormaps checksum get def
  609.  
  610.     /sbs 31 string def
  611.     /txt 5 array def
  612.    
  613.     0 1 4 {
  614.         /i exch def
  615.  
  616.         % Prefix with either a start character or separator character
  617.         i 0 eq {
  618.             sbs 0 encs 10 get putinterval
  619.         } {
  620.             sbs i 1 sub 6 mul 7 add encs 11 get putinterval
  621.         } ifelse
  622.  
  623.         % Lookup the encoding for the barcode character
  624.         barcode i 1 getinterval barchars exch search
  625.         pop                     % Discard true leaving pre
  626.         length /indx exch def   % indx is the length of pre
  627.         pop pop                 % Discard seek and post
  628.         /enc encs indx get def  % Get the indxth encoding
  629.         mirrormap i get 49 eq { % Reverse enc if 1 in this position in mirrormap
  630.             /enclen enc length def
  631.             /revenc enclen string def
  632.             0 1 enclen 1 sub {
  633.                 /j exch def
  634.                 /char enc j get def
  635.                 revenc enclen j sub 1 sub char put
  636.             } for
  637.             /enc revenc def
  638.         } if
  639.         sbs i 6 mul 3 add enc putinterval   % Put encoded digit into sbs
  640.         txt i [barcode i 1 getinterval i 1 sub 9 mul 13 add textpos textfont textsize] put
  641.     } for
  642.  
  643.     % Return the arguments
  644.     /retval 4 dict def
  645.     retval (sbs) [sbs {48 sub} forall] put
  646.     retval (bhs) [16{height}repeat] put
  647.     retval (bbs) [16{0}repeat] put
  648.     includetext {
  649.         retval (txt) txt put
  650.     } if
  651.     retval (opt) useropts put
  652.     retval (guardrightpos) 10 put
  653.     retval (guardrightypos) textpos 4 add put
  654.     retval (bordertop) 10 put
  655.     retval
  656.  
  657.     end
  658.  
  659. } bind def
  660. /ean5 load 0 1 dict put
  661. % --END ENCODER ean5--
  662.  
  663. % --BEGIN ENCODER ean2--
  664. % --DESC: EAN-2 (2 digit addon)
  665. % --EXAM: 05
  666. /ean2 {
  667.  
  668.     0 begin
  669.  
  670.     /options exch def                   % We are given an options string
  671.     /useropts options def
  672.     /barcode exch def                   % We are given a barcode string
  673.  
  674.     /includetext false def               % Enable/disable text
  675.     /textfont /Helvetica def
  676.     /textsize 12 def
  677.     /textpos (unset) def
  678.     /height 0.7 def
  679.     
  680.     % Parse the input options
  681.     options {
  682.         token false eq {exit} if dup length string cvs (=) search
  683.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  684.     } loop
  685.     
  686.     /textfont textfont cvlit def
  687.     /textsize textsize cvr def
  688.     /height height cvr def
  689.     textpos (unset) eq {
  690.         /textpos height 72 mul 1 add def
  691.     } {
  692.         /textpos textpos cvr def
  693.     } ifelse
  694.     
  695.     /barlen barcode length def          % Length of the code
  696.  
  697.     % Create an array containing the character mappings
  698.     /encs
  699.     [ (3211) (2221) (2122) (1411) (1132)
  700.       (1231) (1114) (1312) (1213) (3112)
  701.       (112) (11)
  702.     ] def
  703.  
  704.     % Create a string of the available characters
  705.     /barchars (0123456789) def
  706.  
  707.     % Determine the mirror map based on mod 4 checksum
  708.     /mirrormap [(00) (01) (10) (11)] barcode 0 2 getinterval cvi 4 mod get def
  709.  
  710.     /sbs 13 string def
  711.     /txt 2 array def
  712.     
  713.     0 1 1 {
  714.         /i exch def
  715.  
  716.         % Prefix with either a start character or separator character
  717.         i 0 eq {
  718.             sbs 0 encs 10 get putinterval
  719.         } {
  720.             sbs i 1 sub 6 mul 7 add encs 11 get putinterval
  721.         } ifelse
  722.  
  723.         % Lookup the encoding for the barcode character
  724.         barcode i 1 getinterval barchars exch search
  725.         pop                     % Discard true leaving pre
  726.         length /indx exch def   % indx is the length of pre
  727.         pop pop                 % Discard seek and post
  728.         /enc encs indx get def  % Get the indxth encoding
  729.         mirrormap i get 49 eq { % Reverse enc if 1 in this position in mirrormap    
  730.             /enclen enc length def
  731.             /revenc enclen string def
  732.             0 1 enclen 1 sub {
  733.                 /j exch def
  734.                 /char enc j get def
  735.                 revenc enclen j sub 1 sub char put
  736.             } for
  737.             /enc revenc def
  738.         } if
  739.         sbs i 6 mul 3 add enc putinterval   % Put encoded digit into sbs
  740.         txt i [barcode i 1 getinterval i 1 sub 9 mul 13 add textpos textfont textsize] put
  741.     } for
  742.  
  743.     % Return the arguments
  744.     /retval 4 dict def
  745.     retval (sbs) [sbs {48 sub} forall] put
  746.     retval (bhs) [12{height}repeat] put
  747.     retval (bbs) [12{0}repeat] put
  748.     includetext {
  749.         retval (txt) txt put
  750.     } if
  751.     retval (opt) useropts put
  752.     retval (guardrightpos) 10 put
  753.     retval (guardrightypos) textpos 4 add put
  754.     retval (bordertop) 10 put
  755.     retval
  756.  
  757.     end
  758.  
  759. } bind def
  760. /ean2 load 0 1 dict put
  761. % --END ENCODER ean2--
  762.  
  763. % --BEGIN ENCODER isbn--
  764. % --REQUIRES ean13--
  765. % --DESC: ISBN
  766. % --EXAM: 1-86074-271
  767. /isbn {
  768.  
  769.     0 begin
  770.  
  771.     /options exch def      % We are given an options string
  772.     /useropts options def
  773.     /isbntxt exch def      % We are given the isbn text with dashes
  774.  
  775.     /includetext false def  % Enable/disable ISBN text
  776.     /isbnfont /Courier def
  777.     /isbnsize 9 def
  778.     /isbnpos (unset) def
  779.     /height 1 def
  780.     
  781.     % Parse the input options
  782.     options {
  783.         token false eq {exit} if dup length string cvs (=) search
  784.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  785.     } loop
  786.     
  787.     /isbnfont isbnfont cvlit def
  788.     /isbnsize isbnsize cvr def
  789.     /height height cvr def
  790.     isbnpos (unset) eq {
  791.         /isbnpos height 72 mul 3 add def
  792.     } {
  793.         /isbnpos isbnpos cvr def
  794.     } ifelse
  795.     
  796.     % Read the digits from isbntxt and calculate checksums
  797.     /isbn 13 string def
  798.     /checksum10 0 def
  799.     /checksum13 0 def
  800.     /i 0 def /n 0 def
  801.     { % loop
  802.         /isbnchar isbntxt i get 48 sub def
  803.         isbnchar -3 ne {     % Ignore dashes
  804.             isbn n isbnchar 48 add put
  805.             /checksum10 checksum10 10 n sub isbnchar mul add def
  806.             n 2 mod 0 eq {
  807.                 /checksum13 isbnchar checksum13 add def
  808.             } {
  809.                 /checksum13 isbnchar 3 mul checksum13 add def
  810.             } ifelse
  811.             /n n 1 add def
  812.         } if
  813.         /i i 1 add def
  814.         i isbntxt length eq {exit} if
  815.     } loop
  816.  
  817.     % Add the ISBN header to the isbntxt
  818.     n 9 eq n 10 eq or {
  819.         /checksum 11 checksum10 11 mod sub 11 mod def
  820.         /isbn isbn 0 9 getinterval def
  821.         /pad 18 string def
  822.     } {
  823.         /checksum 10 checksum13 10 mod sub 10 mod def
  824.         /isbn isbn 0 12 getinterval def
  825.         /pad 22 string def
  826.     } ifelse
  827.     pad 0 (ISBN ) putinterval
  828.     pad 5 isbntxt putinterval  % Add isbntxt to the pad
  829.  
  830.     % Add checksum digit if isbntxt length is 11 or 15
  831.     isbntxt length 11 eq isbntxt length 15 eq or {
  832.         pad isbntxt length 5 add 45 put  % Put a dash
  833.         checksum 10 eq {
  834.             pad isbntxt length 6 add checksum 78 add put  % Check digit for 10 is X
  835.         } {
  836.             pad isbntxt length 6 add checksum 48 add put  % Put check digit
  837.         } ifelse
  838.     } if
  839.     /isbntxt pad def                    % isbntxt=pad
  840.  
  841.     % Convert ISBN digits to EAN-13
  842.     /barcode 12 string def
  843.     isbn length 9 eq {        
  844.         barcode 0 (978) putinterval
  845.         barcode 3 isbn putinterval
  846.     } {
  847.         barcode 0 isbn putinterval
  848.     } ifelse
  849.  
  850.     % Get the result of encoding with ean13    
  851.     /args barcode options ean13 def
  852.  
  853.     % Add the ISBN text
  854.     includetext {
  855.         isbn length 9 eq {
  856.             /isbnxpos -1 def
  857.         } {
  858.             /isbnxpos -12 def
  859.         } ifelse
  860.         args (txt) known {
  861.             /txt args (txt) get def
  862.             /newtxt txt length 1 add array def
  863.             newtxt 0 txt putinterval
  864.             newtxt newtxt length 1 sub [isbntxt isbnxpos isbnpos isbnfont isbnsize] put
  865.             args (txt) newtxt put
  866.         } {
  867.             args (txt) [ [isbntxt isbnxpos isbnpos isbnfont isbnsize] ] put
  868.         } ifelse
  869.     } if
  870.  
  871.     args (opt) useropts put
  872.     args
  873.  
  874.     end
  875.  
  876. } bind def
  877. /isbn load 0 1 dict put
  878. % --END ENCODER isbn--
  879.  
  880. % --BEGIN ENCODER code128--
  881. % --DESC: Code 128
  882. % --EXAM: ^104^102Count^0990123456789^101!
  883. /code128 {
  884.  
  885.     0 begin                  % Confine variables to local scope
  886.  
  887.     /options exch def        % We are given an option string
  888.     /useropts options def
  889.     /barcode exch def        % We are given a barcode string
  890.  
  891.     /includetext false def    % Enable/disable text
  892.     /textfont /Courier def
  893.     /textsize 10 def
  894.     /textpos -7 def
  895.     /height 1 def
  896.     
  897.     % Parse the input options
  898.     options {
  899.         token false eq {exit} if dup length string cvs (=) search
  900.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  901.     } loop
  902.     
  903.     /textfont textfont cvlit def
  904.     /textsize textsize cvr def
  905.     /textpos textpos cvr def
  906.     /height height cvr def
  907.     
  908.     % Create an array containing the character mappings
  909.     /encs
  910.     [ (212222) (222122) (222221) (121223) (121322) (131222) (122213)
  911.       (122312) (132212) (221213) (221312) (231212) (112232) (122132)
  912.       (122231) (113222) (123122) (123221) (223211) (221132) (221231)
  913.       (213212) (223112) (312131) (311222) (321122) (321221) (312212)
  914.       (322112) (322211) (212123) (212321) (232121) (111323) (131123)
  915.       (131321) (112313) (132113) (132311) (211313) (231113) (231311)
  916.       (112133) (112331) (132131) (113123) (113321) (133121) (313121)
  917.       (211331) (231131) (213113) (213311) (213131) (311123) (311321)
  918.       (331121) (312113) (312311) (332111) (314111) (221411) (431111)
  919.       (111224) (111422) (121124) (121421) (141122) (141221) (112214)
  920.       (112412) (122114) (122411) (142112) (142211) (241211) (221114)
  921.       (413111) (241112) (134111) (111242) (121142) (121241) (114212)
  922.       (124112) (124211) (411212) (421112) (421211) (212141) (214121)
  923.       (412121) (111143) (111341) (131141) (114113) (114311) (411113)
  924.       (411311) (113141) (114131) (311141) (411131) (211412) (211214)
  925.       (211232) (2331112)
  926.     ] def
  927.  
  928.     % Create a string of the available characters for alphabets A and B
  929.     /barchars ( !"#$%&'\(\)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~) def
  930.     /barlen barcode length def    % Length of the code
  931.     /sbs barlen 6 mul string def  % sbs is 6 times length of barcode
  932.     /txt barlen array def
  933.  
  934.     /mode -1 def         % A=0, B=1, C=2
  935.     /checksum barcode 1 3 getinterval cvi def  % Initialise the checksum
  936.  
  937.     /i 0 def /j 0 def
  938.     { % loop
  939.         i barlen eq {exit} if
  940.         barcode i 1 getinterval (^) eq {
  941.             % indx is given by the next three characters
  942.             /indx barcode i 1 add 3 getinterval cvi def
  943.             txt j [( ) j 11 mul textpos textfont textsize] put
  944.             /i i 4 add def
  945.         } {
  946.             % indx depends on the mode
  947.             mode 2 eq {
  948.                 /indx barcode i 2 getinterval cvi def
  949.                 txt j [barcode i 2 getinterval j 11 mul textpos textfont textsize] put
  950.                 /i i 2 add def
  951.             } {
  952.                 barchars barcode i 1 getinterval search
  953.                 pop                    % Discard true leaving pre
  954.                 length /indx exch def  % indx is the length of pre
  955.                 pop pop                % Discard seek and post
  956.                 txt j [barchars indx 1 getinterval j 11 mul textpos textfont textsize] put
  957.                 /i i 1 add def
  958.             } ifelse
  959.         } ifelse
  960.         /enc encs indx get def         % Get the indxth encoding
  961.         sbs j 6 mul enc putinterval    % Put encoded digit into sbs
  962.  
  963.         % Update the mode
  964.         indx 101 eq indx 103 eq or {/mode 0 def} if
  965.         indx 100 eq indx 104 eq or {/mode 1 def} if
  966.         indx 99 eq indx 105 eq or {/mode 2 def} if
  967.  
  968.         /checksum indx j mul checksum add def  % checksum+=indx*j
  969.         /j j 1 add def
  970.     } loop
  971.  
  972.     % Put the checksum character
  973.     /checksum checksum 103 mod def
  974.     sbs j 6 mul encs checksum get putinterval
  975.  
  976.     % Put the end character
  977.     sbs j 6 mul 6 add encs 106 get putinterval
  978.  
  979.     % Shrink sbs and txt to fit exactly
  980.     /sbs sbs 0 j 6 mul 13 add getinterval def
  981.     /txt txt 0 j getinterval def
  982.  
  983.     % Return the arguments
  984.     /retval 1 dict def
  985.     retval (sbs) [sbs {48 sub} forall] put
  986.     retval (bhs) [sbs length 1 add 2 idiv {height} repeat] put
  987.     retval (bbs) [sbs length 1 add 2 idiv {0} repeat] put
  988.     includetext {
  989.         retval (txt) txt put
  990.     } if
  991.     retval (opt) useropts put
  992.     retval
  993.  
  994.     end
  995.  
  996. } bind def
  997. /code128 load 0 1 dict put
  998. % --END ENCODER code128--
  999.  
  1000. % --BEGIN ENCODER code39--
  1001. % --DESC: Code 39
  1002. % --EXAM: THIS IS CODE 39
  1003. /code39 {
  1004.  
  1005.     0 begin                 % Confine variables to local scope
  1006.  
  1007.     /options exch def       % We are given an option string
  1008.     /useropts options def
  1009.     /barcode exch def       % We are given a barcode string
  1010.  
  1011.     /includecheck false def  % Enable/disable checkdigit
  1012.     /includetext false def
  1013.     /includecheckintext false def
  1014.     /textfont /Courier def
  1015.     /textsize 10 def
  1016.     /textpos -7 def
  1017.     /height 1 def
  1018.     
  1019.     % Parse the input options
  1020.     options {
  1021.         token false eq {exit} if dup length string cvs (=) search
  1022.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  1023.     } loop
  1024.     
  1025.     /textfont textfont cvlit def
  1026.     /textsize textsize cvr def
  1027.     /textpos textpos cvr def
  1028.     /height height cvr def
  1029.     
  1030.     % Create an array containing the character mappings
  1031.     /encs
  1032.     [ (1113313111) (3113111131) (1133111131) (3133111111) (1113311131)
  1033.       (3113311111) (1133311111) (1113113131) (3113113111) (1133113111)
  1034.       (3111131131) (1131131131) (3131131111) (1111331131) (3111331111)
  1035.       (1131331111) (1111133131) (3111133111) (1131133111) (1111333111)
  1036.       (3111111331) (1131111331) (3131111311) (1111311331) (3111311311)
  1037.       (1131311311) (1111113331) (3111113311) (1131113311) (1111313311)
  1038.       (3311111131) (1331111131) (3331111111) (1311311131) (3311311111)
  1039.       (1331311111) (1311113131) (3311113111) (1331113111) (1313131111)
  1040.       (1313111311) (1311131311) (1113131311) (1311313111)
  1041.     ] def
  1042.  
  1043.     % Create a string of the available characters
  1044.     /barchars (0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%*) def
  1045.  
  1046.     /barlen barcode length def  % Length of the code
  1047.  
  1048.     includecheck {
  1049.         /sbs barlen 10 mul 30 add string def
  1050.         /txt barlen 3 add array def
  1051.     } {
  1052.         /sbs barlen 10 mul 20 add string def
  1053.         /txt barlen 2 add array def
  1054.     } ifelse
  1055.  
  1056.     /checksum 0 def
  1057.  
  1058.     % Put the start character
  1059.     sbs 0 encs 43 get putinterval
  1060.     txt 0 [(*) 0 textpos textfont textsize] put
  1061.  
  1062.     0 1 barlen 1 sub {
  1063.         /i exch def
  1064.         % Lookup the encoding for the each barcode character
  1065.         barcode i 1 getinterval barchars exch search
  1066.         pop                                  % Discard true leaving pre
  1067.         length /indx exch def                % indx is the length of pre
  1068.         pop pop                              % Discard seek and post
  1069.         /enc encs indx get def               % Get the indxth encoding
  1070.         sbs i 10 mul 10 add enc putinterval  % Put encoded digit into sbs
  1071.         txt i 1 add [barcode i 1 getinterval i 1 add 16 mul textpos textfont textsize] put
  1072.         /checksum checksum indx add def
  1073.     } for
  1074.  
  1075.     % Put the checksum and end characters
  1076.     includecheck {
  1077.         /checksum checksum 43 mod def
  1078.         sbs barlen 10 mul 10 add encs checksum get putinterval
  1079.         includecheckintext {
  1080.             txt barlen 1 add [barchars checksum 1 getinterval barlen 1 add 16 mul textpos textfont textsize] put
  1081.         } {
  1082.             txt barlen 1 add [() barlen 1 add 16 mul textpos textfont textsize] put
  1083.         } ifelse
  1084.         sbs barlen 10 mul 20 add encs 43 get putinterval
  1085.         txt barlen 2 add [(*) barlen 2 add 16 mul textpos textfont textsize] put
  1086.     } {
  1087.         sbs barlen 10 mul 10 add encs 43 get putinterval
  1088.         txt barlen 1 add [(*) barlen 1 add 16 mul textpos textfont textsize] put
  1089.     } ifelse
  1090.     
  1091.     % Return the arguments
  1092.     /retval 2 dict def
  1093.     retval (sbs) [sbs {48 sub} forall] put
  1094.     retval (bhs) [sbs length 1 add 2 idiv {height} repeat] put
  1095.     retval (bbs) [sbs length 1 add 2 idiv {0} repeat] put
  1096.     includetext {
  1097.         retval (txt) txt put
  1098.     } if
  1099.     retval (opt) useropts put
  1100.     retval
  1101.  
  1102.     end
  1103.  
  1104. } bind def
  1105. /code39 load 0 1 dict put
  1106. % --END ENCODER code39--
  1107.  
  1108. % --BEGIN ENCODER code93--
  1109. % --DESC: Code 93
  1110. % --EXAM: THIS IS CODE 93
  1111. /code93 {
  1112.  
  1113.     0 begin                 % Confine variables to local scope
  1114.  
  1115.     /options exch def       % We are given an option string
  1116.     /useropts options def
  1117.     /barcode exch def       % We are given a barcode string
  1118.  
  1119.     /includecheck false def  % Enable/disable checkdigit
  1120.     /includetext false def   % Enable/disable text
  1121.     /textfont /Courier def
  1122.     /textsize 10 def
  1123.     /textpos -7 def
  1124.     /height 1 def
  1125.     
  1126.     % Parse the input options
  1127.     options {
  1128.         token false eq {exit} if dup length string cvs (=) search
  1129.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  1130.     } loop
  1131.     
  1132.     /textfont textfont cvlit def
  1133.     /textsize textsize cvr def
  1134.     /textpos textpos cvr def
  1135.     /height height cvr def
  1136.     
  1137.     /encs
  1138.     [ (131112) (111213) (111312) (111411) (121113)
  1139.       (121212) (121311) (111114) (131211) (141111)
  1140.       (211113) (211212) (211311) (221112) (221211)
  1141.       (231111) (112113) (112212) (112311) (122112)
  1142.       (132111) (111123) (111222) (111321) (121122)
  1143.       (131121) (212112) (212211) (211122) (211221)
  1144.       (221121) (222111) (112122) (112221) (122121)
  1145.       (123111) (121131) (311112) (311211) (321111)
  1146.       (112131) (113121) (211131) (121221) (312111)
  1147.       (311121) (122211) (111141) (1111411)
  1148.     ] def
  1149.  
  1150.     % Create a string of the available characters
  1151.     /barchars (0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%) def
  1152.  
  1153.     /barlen barcode length def  % Length of the code    
  1154.     barcode {
  1155.         (^) search false eq {pop exit} if
  1156.         pop pop /barlen barlen 3 sub def
  1157.     } loop
  1158.  
  1159.     includecheck {
  1160.         /sbs barlen 6 mul 25 add string def
  1161.     } {
  1162.         /sbs barlen 6 mul 13 add string def
  1163.     } ifelse
  1164.     /txt barlen array def
  1165.     
  1166.     % Put the start character
  1167.     sbs 0 encs 47 get putinterval
  1168.     
  1169.     /checksum1 0 def /checksum2 0 def
  1170.  
  1171.     /i 0 def /j 0 def
  1172.     { % loop
  1173.         j barlen eq {exit} if
  1174.         barcode i 1 getinterval (^) eq {
  1175.             % indx is given by the next three characters
  1176.             /indx barcode i 1 add 3 getinterval cvi def
  1177.             txt j [( ) j 9 mul 9 add textpos textfont textsize] put
  1178.             /i i 4 add def
  1179.         } {
  1180.             barchars barcode i 1 getinterval search
  1181.             pop                         % Discard true leaving pre
  1182.             length /indx exch def       % indx is the length of pre
  1183.             pop pop                     % Discard seek and post
  1184.             txt j [barchars indx 1 getinterval j 9 mul 9 add textpos textfont textsize] put
  1185.             /i i 1 add def
  1186.         } ifelse
  1187.         /enc encs indx get def             % Get the indxth encoding
  1188.         sbs j 6 mul 6 add enc putinterval  % Put encoded digit into sbs
  1189.         /checksum1 checksum1 barlen j sub 1 sub 20 mod 1 add indx mul add def
  1190.         /checksum2 checksum2 barlen j sub 15 mod 1 add indx mul add def
  1191.         /j j 1 add def
  1192.     } loop
  1193.     
  1194.     includecheck {
  1195.         % Put the first checksum character
  1196.         /checksum1 checksum1 47 mod def
  1197.         /checksum2 checksum2 checksum1 add 47 mod def
  1198.         sbs j 6 mul 6 add encs checksum1 get putinterval
  1199.         sbs j 6 mul 12 add encs checksum2 get putinterval
  1200.         % Put the end character
  1201.         sbs j 6 mul 18 add encs 48 get putinterval
  1202.     } {
  1203.         % Put the end character
  1204.         sbs j 6 mul 6 add encs 48 get putinterval      
  1205.     } ifelse
  1206.  
  1207.     % Return the arguments
  1208.     /retval 1 dict def
  1209.     retval (sbs) [sbs {48 sub} forall] put
  1210.     retval (bhs) [sbs length 1 add 2 idiv {height} repeat] put
  1211.     retval (bbs) [sbs length 1 add 2 idiv {0} repeat] put
  1212.     includetext {
  1213.         retval (txt) txt put
  1214.     } if
  1215.     retval (opt) useropts put
  1216.     retval
  1217.  
  1218.     end
  1219.  
  1220. } bind def
  1221. /code93 load 0 1 dict put
  1222. % --END ENCODER code93--
  1223.  
  1224. % --BEGIN ENCODER interleaved2of5--
  1225. % --DESC: Interleaved 2 of 5 (ITF)
  1226. % --EXAM: 24012345678905
  1227. /interleaved2of5 {
  1228.  
  1229.     0 begin         % Confine variables to local scope
  1230.  
  1231.     /options exch def               % We are given an option string
  1232.     /useropts options def
  1233.     /barcode exch def               % We are given a barcode string
  1234.  
  1235.     /includecheck false def         % Enable/disable checkdigit
  1236.     /includetext false def          % Enable/disable text
  1237.     /includecheckintext false def
  1238.     /textfont /Courier def
  1239.     /textsize 10 def
  1240.     /textpos -7 def
  1241.     /height 1 def
  1242.     
  1243.     % Parse the input options
  1244.     options {
  1245.         token false eq {exit} if dup length string cvs (=) search
  1246.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  1247.     } loop
  1248.     
  1249.     /textfont textfont cvlit def
  1250.     /textsize textsize cvr def
  1251.     /textpos textpos cvr def
  1252.     /height height cvr def
  1253.     
  1254.     /barlen barcode length def      % Length of the code
  1255.  
  1256.     % Prefix 0 to barcode if length is even and including checkdigit
  1257.     % or length is odd and not including checkdigit
  1258.     barlen 2 mod 0 eq includecheck and          % even & includecheck
  1259.     barlen 2 mod 0 ne includecheck not and or { % odd  & !includecheck
  1260.         /pad barlen 1 add string def  % Create pad one bigger than barcode
  1261.         pad 0 48 put                  % Put ascii 0 at start of pad
  1262.         pad 1 barcode putinterval     % Add barcode to the end of pad
  1263.         /barcode pad def              % barcode=pad
  1264.         /barlen barlen 1 add def      % barlen++
  1265.     } if
  1266.  
  1267.     % Add checksum to end of barcode
  1268.     includecheck {
  1269.         /checksum 0 def
  1270.         0 1 barlen 1 sub {
  1271.             /i exch def
  1272.             i 2 mod 0 eq {
  1273.                 /checksum checksum barcode i get 48 sub 3 mul add def
  1274.             } {
  1275.                 /checksum checksum barcode i get 48 sub add def
  1276.             } ifelse
  1277.         } for
  1278.         /checksum 10 checksum 10 mod sub 10 mod def
  1279.         /pad barlen 1 add string def    % Create pad one bigger than barcode
  1280.         pad 0 barcode putinterval       % Add barcode to the start of pad
  1281.         pad barlen checksum 48 add put  % Add checksum to end of pad
  1282.         /barcode pad def                % barcode=pad
  1283.         /barlen barlen 1 add def        % barlen++
  1284.     } if
  1285.  
  1286.     % Create an array containing the character mappings
  1287.     /encs
  1288.     [ (11331) (31113) (13113) (33111) (11313)
  1289.       (31311) (13311) (11133) (31131) (13131)
  1290.       (1111)  (3111)
  1291.     ] def
  1292.  
  1293.     % Create a string of the available characters
  1294.     /barchars (0123456789) def
  1295.     /sbs barlen 5 mul 8 add string def
  1296.     /txt barlen array def
  1297.  
  1298.     % Put the start character
  1299.     sbs 0 encs 10 get putinterval
  1300.  
  1301.     0 2 barlen 1 sub {
  1302.     /i exch def
  1303.         % Lookup the encodings for two consecutive barcode characters
  1304.         barcode i 1 getinterval barchars exch search
  1305.         pop                           % Discard true leaving pre
  1306.         length /indx exch def         % indx is the length of pre
  1307.         pop pop                       % Discard seek and post
  1308.         /enca encs indx get def       % Get the indxth encoding
  1309.  
  1310.         barcode i 1 add 1 getinterval barchars exch search
  1311.         pop                           % Discard true leaving pre
  1312.         length /indx exch def         % indx is the length of pre
  1313.         pop pop                       % Discard seek and post
  1314.         /encb encs indx get def       % Get the indxth encoding
  1315.  
  1316.         % Interleave the two character encodings
  1317.         /intl enca length 2 mul string def
  1318.         0 1 enca length 1 sub {
  1319.             /j exch def
  1320.             /achar enca j get def
  1321.             /bchar encb j get def
  1322.             intl j 2 mul achar put
  1323.             intl j 2 mul 1 add bchar put
  1324.         } for
  1325.  
  1326.         sbs i 5 mul 4 add intl putinterval   % Put encoded digit into sbs
  1327.         txt i [barcode i 1 getinterval i 9 mul 4 add textpos textfont textsize] put
  1328.         includecheck includecheckintext not and barlen 2 sub i eq and {
  1329.             txt i 1 add [( ) i 1 add 9 mul 4 add textpos textfont textsize] put
  1330.         } {
  1331.             txt i 1 add [barcode i 1 add 1 getinterval i 1 add 9 mul 4 add textpos textfont textsize] put
  1332.         } ifelse
  1333.     } for
  1334.  
  1335.     % Put the end character
  1336.     sbs barlen 5 mul 4 add encs 11 get putinterval
  1337.  
  1338.     % Return the arguments
  1339.     /retval 1 dict def
  1340.     retval (sbs) [sbs {48 sub} forall] put
  1341.     retval (bhs) [sbs length 1 add 2 idiv {height} repeat] put
  1342.     retval (bbs) [sbs length 1 add 2 idiv {0} repeat] put
  1343.     includetext {
  1344.         retval (txt) txt put
  1345.     } if
  1346.     retval (opt) useropts put
  1347.     retval
  1348.  
  1349.     end
  1350.  
  1351. } bind def
  1352. /interleaved2of5 load 0 1 dict put
  1353. % --END ENCODER interleaved2of5--
  1354.  
  1355. % --BEGIN ENCODER rss14--
  1356. % --DESC: Reduced Space Symbology 14 (RSS-14)
  1357. % --EXAM: 24012345678905
  1358. /rss14 {
  1359.  
  1360.     0 begin            % Confine variables to local scope
  1361.  
  1362.     /options exch def  % We are given an option string
  1363.     /useropts options def
  1364.     /barcode exch def  % We are given a barcode string
  1365.  
  1366.     /height 1 def
  1367.     /linkage false def
  1368.     
  1369.     % Parse the input options
  1370.     options {
  1371.         token false eq {exit} if dup length string cvs (=) search
  1372.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  1373.     } loop
  1374.     
  1375.     /height height cvr def
  1376.  
  1377.     /getRSSwidths {     
  1378.         /mw exch def
  1379.         /nm exch def
  1380.         /val exch def
  1381.         /j 0 def /i 0 def {
  1382.             /v () def
  1383.             mw 1 ne {/v i mw 4 string cvrs def} if          
  1384.             0 v {48 sub add} forall 4 add nm eq {               
  1385.                 j val eq {exit} if
  1386.                 /j j 1 add def
  1387.             } if
  1388.             /i i 1 add def
  1389.         } loop
  1390.         [4 {1} repeat v {47 sub} forall] v length 4 getinterval
  1391.     } bind def
  1392.  
  1393.     /binval [barcode {48 sub} forall] def
  1394.     /binval [linkage {1} {0} ifelse binval 0 13 getinterval {} forall] def
  1395.     
  1396.     0 1 12 {
  1397.         /i exch def
  1398.         binval i 1 add 2 copy get binval i get 4537077 mod 10 mul add put
  1399.         binval i binval i get 4537077 idiv put
  1400.     } for
  1401.     /right binval 13 get 4537077 mod def
  1402.     binval 13 2 copy get 4537077 idiv put
  1403.  
  1404.     /left 0 def
  1405.     /i true def
  1406.     0 1 13 {
  1407.         /j exch def
  1408.         binval j get
  1409.         dup 0 eq i and {
  1410.             pop
  1411.         } {
  1412.             /i false def
  1413.             /left left 3 -1 roll 10 13 j sub exp cvi mul add def
  1414.         } ifelse
  1415.     } for
  1416.     
  1417.     /d1 left 1597 idiv def
  1418.     /d2 left 1597 mod def
  1419.     /d3 right 1597 idiv def
  1420.     /d4 right 1597 mod def
  1421.  
  1422.     /tab164 [
  1423.         160   0     12 4   8 1  161   1
  1424.         960   161   10 6   6 3  80   10
  1425.         2014  961   8  8   4 5  31   34
  1426.         2714  2015  6  10  3 6  10   70
  1427.         2840  2715  4  12  1 8  1    126
  1428.     ] def
  1429.  
  1430.     /tab154 [
  1431.         335   0     5  10  2 7  4   84
  1432.         1035  336   7  8   4 5  20  35
  1433.         1515  1036  9  6   6 3  48  10
  1434.         1596  1516  11 4   8 1  81  1
  1435.     ] def
  1436.  
  1437.     /i 0 def {
  1438.         d1 tab164 i get le {
  1439.             tab164 i 1 add 7 getinterval {} forall
  1440.             /d1te exch def /d1to exch def
  1441.             /d1mwe exch def /d1mwo exch def
  1442.             /d1ele exch def /d1elo exch def
  1443.             /d1gs exch def
  1444.             exit
  1445.         } if
  1446.         /i i 8 add def
  1447.     } loop
  1448.  
  1449.     /i 0 def {
  1450.         d2 tab154 i get le {
  1451.             tab154 i 1 add 7 getinterval {} forall
  1452.             /d2te exch def /d2to exch def
  1453.             /d2mwe exch def /d2mwo exch def
  1454.             /d2ele exch def /d2elo exch def
  1455.             /d2gs exch def
  1456.             exit
  1457.         } if
  1458.         /i i 8 add def
  1459.     } loop
  1460.  
  1461.     /i 0 def {
  1462.         d3 tab164 i get le {
  1463.             tab164 i 1 add 7 getinterval {} forall
  1464.             /d3te exch def /d3to exch def
  1465.             /d3mwe exch def /d3mwo exch def
  1466.             /d3ele exch def /d3elo exch def
  1467.             /d3gs exch def
  1468.             exit
  1469.         } if
  1470.         /i i 8 add def
  1471.     } loop
  1472.  
  1473.     /i 0 def {
  1474.         d4 tab154 i get le {
  1475.             tab154 i 1 add 7 getinterval {} forall
  1476.             /d4te exch def /d4to exch def
  1477.             /d4mwe exch def /d4mwo exch def
  1478.             /d4ele exch def /d4elo exch def
  1479.             /d4gs exch def
  1480.             exit
  1481.         } if
  1482.         /i i 8 add def
  1483.     } loop
  1484.     
  1485.     /d1wo d1 d1gs sub d1te idiv d1elo d1mwo getRSSwidths def
  1486.     /d1we d1 d1gs sub d1te mod d1ele d1mwe getRSSwidths def
  1487.     /d2wo d2 d2gs sub d2to mod d2elo d2mwo getRSSwidths def
  1488.     /d2we d2 d2gs sub d2to idiv d2ele d2mwe getRSSwidths def
  1489.     /d3wo d3 d3gs sub d3te idiv d3elo d3mwo getRSSwidths def
  1490.     /d3we d3 d3gs sub d3te mod d3ele d3mwe getRSSwidths def
  1491.     /d4wo d4 d4gs sub d4to mod d4elo d4mwo getRSSwidths def
  1492.     /d4we d4 d4gs sub d4to idiv d4ele d4mwe getRSSwidths def
  1493.  
  1494.     /d1w 8 array def
  1495.     0 1 3 {
  1496.         /i exch def
  1497.         d1w i 2 mul d1wo i get put
  1498.         d1w i 2 mul 1 add d1we i get put
  1499.     } for
  1500.  
  1501.     /d2w 8 array def
  1502.     0 1 3 {
  1503.         /i exch def
  1504.         d2w 7 i 2 mul sub d2wo i get put
  1505.         d2w 6 i 2 mul sub d2we i get put
  1506.     } for
  1507.     
  1508.     /d3w 8 array def
  1509.     0 1 3 {
  1510.         /i exch def
  1511.         d3w 7 i 2 mul sub d3wo i get put
  1512.         d3w 6 i 2 mul sub d3we i get put
  1513.     } for
  1514.     
  1515.     /d4w 8 array def
  1516.     0 1 3 {
  1517.         /i exch def
  1518.         d4w i 2 mul d4wo i get put
  1519.         d4w i 2 mul 1 add d4we i get put
  1520.     } for
  1521.  
  1522.     /widths [
  1523.         d1w {} forall
  1524.         d2w {} forall
  1525.         d3w {} forall
  1526.         d4w {} forall
  1527.     ] def
  1528.     
  1529.     /checkweights [
  1530.         1   3   9   27  2   6   18  54
  1531.         58  72  24  8   29  36  12  4
  1532.         74  51  17  32  37  65  48  16
  1533.         64  34  23  69  49  68  46  59
  1534.     ] def
  1535.  
  1536.     /checkwidths [
  1537.         3 8 2 1 1   3 5 5 1 1   3 3 7 1 1
  1538.         3 1 9 1 1   2 7 4 1 1   2 5 6 1 1
  1539.         2 3 8 1 1   1 5 7 1 1   1 3 9 1 1
  1540.     ] def
  1541.     
  1542.     /checksum 0 def
  1543.     0 1 31 {
  1544.         /i exch def
  1545.         /checksum checksum widths i get checkweights i get mul add def 
  1546.     } for
  1547.     /checksum checksum 79 mod def    
  1548.     checksum 8 ge {/checksum checksum 1 add def} if
  1549.     checksum 72 ge {/checksum checksum 1 add def} if
  1550.     /checklt checkwidths checksum 9 idiv 5 mul 5 getinterval def
  1551.     /checkrtrev checkwidths checksum 9 mod 5 mul 5 getinterval def
  1552.     /checkrt 5 array def
  1553.     0 1 4 {
  1554.         /i exch def
  1555.         checkrt i checkrtrev 4 i sub get put
  1556.     } for
  1557.  
  1558.     /sbs [
  1559.         1 d1w {} forall checklt {} forall d2w {}
  1560.         forall d4w {} forall checkrt {} forall d3w {} forall 1 1
  1561.     ] def
  1562.     
  1563.     % Return the arguments
  1564.     /retval 1 dict def
  1565.     retval (sbs) sbs put
  1566.     retval (bhs) [sbs length 1 add 2 idiv {height} repeat] put
  1567.     retval (bbs) [sbs length 1 add 2 idiv {0} repeat] put   
  1568.     retval (opt) useropts put
  1569.     retval
  1570.  
  1571.     end
  1572.  
  1573. } bind def
  1574. /rss14 load 0 1 dict put
  1575. % --END ENCODER rss14--
  1576.  
  1577. % --BEGIN ENCODER rsslimited--
  1578. % --DESC: Reduced Space Symbology Limited (RSS-Limited)
  1579. % --EXAM: 00978186074271
  1580. /rsslimited {
  1581.  
  1582.     0 begin            % Confine variables to local scope
  1583.  
  1584.     /options exch def  % We are given an option string
  1585.     /useropts options def
  1586.     /barcode exch def  % We are given a barcode string
  1587.  
  1588.     /height 1 def
  1589.     
  1590.     % Parse the input options
  1591.     options {
  1592.         token false eq {exit} if dup length string cvs (=) search
  1593.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  1594.     } loop
  1595.     
  1596.     /height height cvr def
  1597.  
  1598.     /getRSSwidths {
  1599.         /el exch def
  1600.         /mw exch def
  1601.         /nm exch def
  1602.         /val exch def
  1603.         /j 0 def /i 0 def {
  1604.             /v () def
  1605.             mw 1 ne {/v i mw el string cvrs def} if          
  1606.             0 v {48 sub add} forall el add nm eq {               
  1607.                 j val eq {exit} if
  1608.                 /j j 1 add def
  1609.             } if
  1610.             /i i 1 add def
  1611.         } loop
  1612.         [el {1} repeat v {47 sub} forall] v length el getinterval
  1613.     } bind def
  1614.     
  1615.     /binval [barcode {48 sub} forall] def
  1616.     /binval [binval 0 13 getinterval {} forall] def
  1617.     
  1618.     0 1 11 {
  1619.         /i exch def
  1620.         binval i 1 add 2 copy get binval i get 2013571 mod 10 mul add put
  1621.         binval i binval i get 2013571 idiv put
  1622.     } for
  1623.     /d2 binval 12 get 2013571 mod def
  1624.     binval 12 2 copy get 2013571 idiv put
  1625.  
  1626.     /d1 0 def
  1627.     /i true def
  1628.     0 1 12 {
  1629.         /j exch def
  1630.         binval j get
  1631.         dup 0 eq i and {
  1632.             pop
  1633.         } {
  1634.             /i false def
  1635.             /d1 d1 3 -1 roll 10 12 j sub exp cvi mul add def
  1636.         } ifelse
  1637.     } for
  1638.     
  1639.     /tab267 [
  1640.         183063   0        17 9   6 3  6538   28
  1641.         820063   183064   13 13  5 4  875    728
  1642.         1000775  820064   9  17  3 6  28     6454
  1643.         1491020  1000776  15 11  5 4  2415   203
  1644.         1979844  1491021  11 15  4 5  203    2408
  1645.         1996938  1979845  19 7   8 1  17094  1
  1646.         2013570  1996939  7  19  1 8  1      16632
  1647.     ] def
  1648.  
  1649.     /i 0 def {
  1650.         d1 tab267 i get le {
  1651.             tab267 i 1 add 7 getinterval {} forall
  1652.             /d1te exch def /d1to exch def
  1653.             /d1mwe exch def /d1mwo exch def
  1654.             /d1ele exch def /d1elo exch def
  1655.             /d1gs exch def
  1656.             exit
  1657.         } if
  1658.         /i i 8 add def
  1659.     } loop
  1660.  
  1661.     /i 0 def {
  1662.         d2 tab267 i get le {
  1663.             tab267 i 1 add 7 getinterval {} forall
  1664.             /d2te exch def /d2to exch def
  1665.             /d2mwe exch def /d2mwo exch def
  1666.             /d2ele exch def /d2elo exch def
  1667.             /d2gs exch def
  1668.             exit
  1669.         } if
  1670.         /i i 8 add def
  1671.     } loop
  1672.     
  1673.     /d1wo d1 d1gs sub d1te idiv d1elo d1mwo 7 getRSSwidths def    
  1674.     /d1we d1 d1gs sub d1te mod d1ele d1mwe 7 getRSSwidths def
  1675.     /d2wo d2 d2gs sub d2te idiv d2elo d2mwo 7 getRSSwidths def    
  1676.     /d2we d2 d2gs sub d2te mod d2ele d2mwe 7 getRSSwidths def
  1677.     
  1678.     /d1w 14 array def
  1679.     0 1 6 {
  1680.         /i exch def
  1681.         d1w i 2 mul d1wo i get put
  1682.         d1w i 2 mul 1 add d1we i get put
  1683.     } for
  1684.  
  1685.     /d2w 14 array def
  1686.     0 1 6 {
  1687.         /i exch def
  1688.         d2w i 2 mul d2wo i get put
  1689.         d2w i 2 mul 1 add d2we i get put
  1690.     } for
  1691.  
  1692.     /widths [
  1693.         d1w {} forall
  1694.         d2w {} forall
  1695.     ] def
  1696.     
  1697.     /checkweights [
  1698.         1  3  9  27 81 65 17 51 64 14 42 37 22 66
  1699.         20 60 2  6  18 54 73 41 34 13 39 28 84 74
  1700.     ] def
  1701.  
  1702.     /checkseq [
  1703.         0 1 43 {} for
  1704.         45 52 57
  1705.         63 1 66 {} for
  1706.         73 1 79 {} for
  1707.         82
  1708.         126 1 130 {} for
  1709.         132
  1710.         141 1 146 {} for
  1711.         210 1 217 {} for
  1712.         220
  1713.         316 1 323 {} for
  1714.         326 337
  1715.     ] def
  1716.     
  1717.     /checksum 0 def
  1718.     0 1 27 {
  1719.         /i exch def
  1720.         /checksum checksum widths i get checkweights i get mul add def
  1721.     } for
  1722.     /checksum checksum 89 mod def
  1723.     /seq checkseq checksum get def
  1724.     /swidths seq 21 idiv 8 3 6 getRSSwidths def
  1725.     /bwidths seq 21 mod 8 3 6 getRSSwidths def
  1726.  
  1727.     /checkwidths [0 0 0 0 0 0 0 0 0 0 0 0 1 1] def
  1728.     0 1 5 {
  1729.         /i exch def
  1730.         checkwidths i 2 mul swidths i get put
  1731.         checkwidths i 2 mul 1 add bwidths i get put
  1732.     } for
  1733.     
  1734.     /sbs [
  1735.         1 d1w {} forall checkwidths {} forall d2w {} forall 1 1
  1736.     ] def
  1737.     
  1738.     % Return the arguments
  1739.     /retval 1 dict def
  1740.     retval (sbs) sbs put
  1741.     retval (bhs) [sbs length 1 add 2 idiv {height} repeat] put
  1742.     retval (bbs) [sbs length 1 add 2 idiv {0} repeat] put   
  1743.     retval (opt) useropts put
  1744.     retval
  1745.  
  1746.     end
  1747.  
  1748. } bind def
  1749. /rsslimited load 0 1 dict put
  1750. % --END ENCODER rsslimited--
  1751.  
  1752. % --BEGIN ENCODER rssexpanded--
  1753. % --DESC: Reduced Space Symbology Expanded (RSS-Expanded)
  1754. % --EXAM: 000000010011001010100001000000010000
  1755. /rssexpanded {
  1756.  
  1757.     0 begin            % Confine variables to local scope
  1758.  
  1759.     /options exch def  % We are given an option string
  1760.     /useropts options def
  1761.     /barcode exch def  % We are given a barcode string
  1762.  
  1763.     /height 1 def
  1764.     
  1765.     % Parse the input options
  1766.     options {
  1767.         token false eq {exit} if dup length string cvs (=) search
  1768.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  1769.     } loop
  1770.     
  1771.     /height height cvr def
  1772.  
  1773.     /getRSSwidths {     
  1774.         /mw exch def
  1775.         /nm exch def
  1776.         /val exch def
  1777.         /j 0 def /i 0 def {
  1778.             /v () def
  1779.             mw 1 ne {/v i mw 4 string cvrs def} if          
  1780.             0 v {48 sub add} forall 4 add nm eq {               
  1781.                 j val eq {exit} if
  1782.                 /j j 1 add def
  1783.             } if
  1784.             /i i 1 add def
  1785.         } loop
  1786.         [4 {1} repeat v {47 sub} forall] v length 4 getinterval
  1787.     } bind def
  1788.  
  1789.     /binval [barcode {48 sub} forall] def
  1790.     /datalen binval length 12 idiv def
  1791.     
  1792.     /tab174 [
  1793.         347   0     12 5   7 2  87  4
  1794.         1387  348   10 7   5 4  52  20
  1795.         2947  1388  8  9   4 5  30  52
  1796.         3987  2948  6  11  3 6  10  104
  1797.         4191  3988  4  13  1 8  1   204
  1798.     ] def
  1799.  
  1800.     /dxw datalen array def
  1801.     
  1802.     0 1 datalen 1 sub {
  1803.  
  1804.         /x exch def
  1805.  
  1806.         /d binval x 12 mul 12 getinterval def
  1807.         /d 0 0 1 11 {/j exch def 2 11 j sub exp cvi d j get mul add} for def
  1808.  
  1809.         /j 0 def {
  1810.             d tab174 j get le {
  1811.                 tab174 j 1 add 7 getinterval {} forall
  1812.                 /dte exch def /dto exch def
  1813.                 /dmwe exch def /dmwo exch def
  1814.                 /dele exch def /delo exch def
  1815.                 /dgs exch def
  1816.                 exit
  1817.             } if
  1818.             /j j 8 add def
  1819.         } loop
  1820.  
  1821.         /dwo d dgs sub dte idiv delo dmwo getRSSwidths def
  1822.         /dwe d dgs sub dte mod dele dmwe getRSSwidths def
  1823.  
  1824.         /dw 8 array def        
  1825.         x 2 mod 0 eq {                    
  1826.             0 1 3 {
  1827.                 /j exch def
  1828.                 dw 7 j 2 mul sub dwo j get put
  1829.                 dw 6 j 2 mul sub dwe j get put
  1830.             } for
  1831.         } {           
  1832.             0 1 3 {
  1833.                 /j exch def
  1834.                 dw j 2 mul dwo j get put
  1835.                 dw j 2 mul 1 add dwe j get put
  1836.             } for
  1837.         } ifelse
  1838.  
  1839.         dxw x dw put
  1840.  
  1841.     } for
  1842.     
  1843.     /widths [
  1844.         dxw {{} forall} forall
  1845.     ] def
  1846.  
  1847.     /checkweights [
  1848.         77   96   32   81   27   9    3    1
  1849.         20   60   180  118  143  7    21   63
  1850.         205  209  140  117  39   13   145  189
  1851.         193  157  49   147  19   57   171  91
  1852.         132  44   85   169  197  136  186  62
  1853.         185  133  188  142  4    12   36   108
  1854.         50   87   29   80   97   173  128  113
  1855.         150  28   84   41   123  158  52   156
  1856.         166  196  206  139  187  203  138  46
  1857.         76   17   51   153  37   111  122  155
  1858.         146  119  110  107  106  176  129  43
  1859.         16   48   144  10   30   90   59   177
  1860.         164  125  112  178  200  137  116  109
  1861.         70   210  208  202  184  130  179  115
  1862.         190  204  68   93   31   151  191  134
  1863.         148  22   66   198  172  94   71   2
  1864.         40   154  192  64   162  54   18   6
  1865.         120  149  25   75   14   42   126  167
  1866.         175  199  207  69   23   78   26   79
  1867.         103  98   83   38   114  131  182  124
  1868.         159  53   88   170  127  183  61   161
  1869.         55   165  73   8    24   72   5    15
  1870.         89   100  174  58   160  194  135  45
  1871.     ] def
  1872.     
  1873.     /checksum 0 def
  1874.     0 1 widths length 1 sub {
  1875.         /i exch def
  1876.         /checksum checksum widths i get checkweights i get mul add def 
  1877.     } for
  1878.     /checksum checksum 211 mod datalen 3 sub 211 mul add def
  1879.  
  1880.     /i 0 def {
  1881.         checksum tab174 i get le {
  1882.             tab174 i 1 add 7 getinterval {} forall
  1883.             /cte exch def /cto exch def
  1884.             /cmwe exch def /cmwo exch def
  1885.             /cele exch def /celo exch def
  1886.             /cgs exch def
  1887.             exit
  1888.         } if
  1889.         /i i 8 add def
  1890.     } loop
  1891.  
  1892.     /cwo checksum cgs sub cte idiv celo cmwo getRSSwidths def
  1893.     /cwe checksum cgs sub cte mod cele cmwe getRSSwidths def
  1894.     
  1895.     /cw 8 array def        
  1896.     0 1 3 {
  1897.         /i exch def
  1898.         cw i 2 mul cwo i get put
  1899.         cw i 2 mul 1 add cwe i get put
  1900.     } for
  1901.     
  1902.     /finderwidths [
  1903.         1 8 4 1 1    1 1 4 8 1
  1904.         3 6 4 1 1    1 1 4 6 3
  1905.         3 4 6 1 1    1 1 6 4 3
  1906.         3 2 8 1 1    1 1 8 2 3
  1907.         2 6 5 1 1    1 1 5 6 2
  1908.         2 2 9 1 1    1 1 9 2 2
  1909.     ] def
  1910.  
  1911.     /finderseq [
  1912.         [0 1]
  1913.         [0 3 2]
  1914.         [0 5 2 7]
  1915.         [0 9 2 7 4]
  1916.         [0 9 2 7 6 11]
  1917.         [0 9 2 7 8 11 10]
  1918.         [0 1 2 3 4 5 6 7]
  1919.         [0 1 2 3 4 5 6 9 8]
  1920.         [0 1 2 3 4 5 6 9 10 11]
  1921.         [0 1 2 3 4 7 6 9 8 11 10]
  1922.     ] def
  1923.  
  1924.     /seq finderseq datalen 2 add 2 idiv 2 sub get def
  1925.     /fxw seq length array def
  1926.     0 1 seq length 1 sub {
  1927.         /x exch def
  1928.         fxw x finderwidths seq x get 5 mul 5 getinterval put
  1929.     } for
  1930.     
  1931.     /sbs [
  1932.         1
  1933.         cw {} forall
  1934.         0 1 datalen 1 sub {
  1935.             /i exch def
  1936.             i 2 mod 0 eq {fxw i 2 idiv get {} forall} if
  1937.             dxw i get {} forall
  1938.         } for
  1939.         1 1
  1940.     ] def
  1941.     
  1942.     % Return the arguments
  1943.     /retval 1 dict def
  1944.     retval (sbs) sbs put
  1945.     retval (bhs) [sbs length 1 add 2 idiv {height} repeat] put
  1946.     retval (bbs) [sbs length 1 add 2 idiv {0} repeat] put   
  1947.     retval (opt) useropts put
  1948.     retval
  1949.  
  1950.     end
  1951.  
  1952. } bind def
  1953. /rssexpanded load 0 1 dict put
  1954. % --END ENCODER rssexpanded--
  1955.  
  1956. % --BEGIN ENCODER code2of5--
  1957. % --DESC: Code 25
  1958. % --EXAM: 01234567
  1959. /code2of5 {
  1960.  
  1961.     % Thanks to Michael Landers
  1962.  
  1963.     0 begin                 % Confine variable to local scope
  1964.  
  1965.     /options exch def       % We are given an option string
  1966.     /useropts options def
  1967.     /barcode exch def       % We are given a barcode string
  1968.  
  1969.     /includecheck false def
  1970.     /includetext false def   % Enable/disable text
  1971.     /includecheckintext false def
  1972.     /textfont /Courier def
  1973.     /textsize 10 def
  1974.     /textpos -7 def
  1975.     /height 1 def
  1976.     
  1977.     % Parse the input options
  1978.     options {
  1979.         token false eq {exit} if dup length string cvs (=) search
  1980.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  1981.     } loop
  1982.     
  1983.     /textfont textfont cvlit def
  1984.     /textsize textsize cvr def
  1985.     /textpos textpos cvr def
  1986.     /height height cvr def
  1987.     
  1988.     % Create an array containing the character mappings
  1989.     /encs
  1990.     [ (1111313111) (3111111131) (1131111131) (3131111111)
  1991.       (1111311131) (3111311111) (1131311111) (1111113131)
  1992.       (3111113111) (1131113111) (313111) (311131)
  1993.     ] def
  1994.  
  1995.     % Create a string of the available characters
  1996.     /barchars (0123456789) def
  1997.  
  1998.     /barlen barcode length def            % Length of the code
  1999.  
  2000.     includecheck {
  2001.         /sbs barlen 10 mul 22 add string def
  2002.         /txt barlen 1 add array def
  2003.     } {
  2004.         /sbs barlen 10 mul 12 add string def
  2005.         /txt barlen array def
  2006.     } ifelse
  2007.     
  2008.     % Put the start character
  2009.     sbs 0 encs 10 get putinterval
  2010.  
  2011.     /checksum 0 def
  2012.     
  2013.     0 1 barlen 1 sub {
  2014.         /i exch def
  2015.         % Lookup the encoding for the each barcode character
  2016.         barcode i 1 getinterval barchars exch search
  2017.         pop                                 % Discard true leaving pre
  2018.         length /indx exch def               % indx is the length of pre
  2019.         pop pop                             % Discard seek and post
  2020.         /enc encs indx get def              % Get the indxth encoding
  2021.         sbs i 10 mul 6 add enc putinterval  % Put encoded digit into sbs
  2022.         txt i [barcode i 1 getinterval i 14 mul 10 add textpos textfont textsize] put
  2023.         barlen i sub 2 mod 0 eq {
  2024.             /checksum checksum indx add def
  2025.         } {            
  2026.             /checksum checksum indx 3 mul add def
  2027.         } ifelse        
  2028.     } for
  2029.     
  2030.     % Put the checksum and end characters
  2031.     includecheck {
  2032.         /checksum 10 checksum 10 mod sub 10 mod def
  2033.         sbs barlen 10 mul 6 add encs checksum get putinterval
  2034.         sbs barlen 10 mul 16 add encs 11 get putinterval
  2035.         includecheckintext {
  2036.             txt barlen [barchars checksum 1 getinterval barlen 14 mul 10 add textpos textfont textsize] put
  2037.         } {            
  2038.             txt barlen [( ) barlen 14 mul 10 add textpos textfont textsize] put
  2039.         } ifelse
  2040.     } {
  2041.         sbs barlen 10 mul 6 add encs 11 get putinterval
  2042.     } ifelse
  2043.     
  2044.     % Return the arguments
  2045.     /retval 1 dict def
  2046.     retval (sbs) [sbs {48 sub} forall] put
  2047.     retval (bhs) [sbs length 1 add 2 idiv {height} repeat] put
  2048.     retval (bbs) [sbs length 1 add 2 idiv {0} repeat] put
  2049.     includetext {
  2050.         retval (txt) txt put
  2051.     } if
  2052.     retval (opt) useropts put
  2053.     retval
  2054.  
  2055.     end
  2056.  
  2057. } bind def
  2058. /code2of5 load 0 1 dict put
  2059. % --END ENCODER code2of5--
  2060.  
  2061. % --BEGIN ENCODER code11--
  2062. % --DESC: Code 11
  2063. % --EXAM: 0123456789
  2064. /code11 {
  2065.  
  2066.     0 begin            % Confine variables to local scope
  2067.  
  2068.     /options exch def  % We are given an option string
  2069.     /useropts options def
  2070.     /barcode exch def  % We are given a barcode string
  2071.  
  2072.     /includecheck false def
  2073.     /includetext false def
  2074.     /includecheckintext false def
  2075.     /textfont /Courier def
  2076.     /textsize 10 def
  2077.     /textpos -7 def
  2078.     /height 1 def
  2079.     
  2080.     % Parse the input options
  2081.     options {
  2082.         token false eq {exit} if dup length string cvs (=) search
  2083.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  2084.     } loop
  2085.     
  2086.     /textfont textfont cvlit def
  2087.     /textsize textsize cvr def
  2088.     /textpos textpos cvr def
  2089.     /height height cvr def
  2090.     
  2091.     % Create an array containing the character mappings
  2092.     /encs
  2093.     [ (111131) (311131) (131131) (331111) (113131)
  2094.       (313111) (133111) (111331) (311311) (311111)
  2095.       (113111) (113311)
  2096.     ] def
  2097.  
  2098.     % Create a string of the available characters
  2099.     /barchars (0123456789-) def
  2100.  
  2101.     /barlen barcode length def        % Length of the code
  2102.  
  2103.     includecheck {
  2104.         barlen 10 ge {
  2105.             /sbs barlen 6 mul 24 add string def
  2106.             /txt barlen 2 add array def
  2107.         } {
  2108.             /sbs barlen 6 mul 18 add string def
  2109.             /txt barlen 1 add array def
  2110.         } ifelse
  2111.     } {
  2112.         /sbs barlen 6 mul 12 add string def
  2113.         /txt barlen array def
  2114.     } ifelse
  2115.  
  2116.     % Put the start character
  2117.     sbs 0 encs 10 get putinterval
  2118.  
  2119.     /checksum1 0 def /checksum2 0 def
  2120.     
  2121.     /xpos 8 def
  2122.     0 1 barlen 1 sub {
  2123.         /i exch def
  2124.         % Lookup the encoding for the each barcode character
  2125.         barcode i 1 getinterval barchars exch search
  2126.         pop                                % Discard true leaving pre
  2127.         length /indx exch def              % indx is the length of pre
  2128.         pop pop                            % Discard seek and post
  2129.         /enc encs indx get def             % Get the indxth encoding
  2130.         sbs i 6 mul 6 add enc putinterval  % Put encoded digit into sbs
  2131.         txt i [barcode i 1 getinterval xpos textpos textfont textsize] put
  2132.         0 1 5 {       % xpos+=width of the character
  2133.             /xpos exch enc exch get 48 sub xpos add def
  2134.         } for
  2135.         /checksum1 checksum1 barlen i sub 1 sub 10 mod 1 add indx mul add def
  2136.         /checksum2 checksum2 barlen i sub 9 mod 1 add indx mul add def
  2137.     } for
  2138.    
  2139.     % Put the checksum and end characters
  2140.     includecheck {
  2141.         /checksum1 checksum1 11 mod def        
  2142.         barlen 10 ge {
  2143.             /checksum2 checksum2 checksum1 add 11 mod def
  2144.             sbs barlen 6 mul 6 add encs checksum1 get putinterval        
  2145.             sbs barlen 6 mul 12 add encs checksum2 get putinterval
  2146.             includecheckintext {
  2147.                 txt barlen [barchars checksum1 1 getinterval xpos textpos textfont textsize] put
  2148.                 /enc encs checksum1 get def   
  2149.                 0 1 5 {       % xpos+=width of the character
  2150.                     /xpos exch enc exch get 48 sub xpos add def
  2151.                 } for
  2152.                 txt barlen 1 add [barchars checksum2 1 getinterval xpos textpos textfont textsize] put
  2153.             } {
  2154.                 txt barlen [() xpos textpos textfont textsize] put
  2155.                 txt barlen 1 add [() xpos textpos textfont textsize] put
  2156.             } ifelse
  2157.             sbs barlen 6 mul 18 add encs 11 get putinterval
  2158.         } {
  2159.             sbs barlen 6 mul 6 add encs checksum1 get putinterval          
  2160.             includecheckintext {
  2161.                 txt barlen [barchars checksum1 1 getinterval xpos textpos textfont textsize] put
  2162.             } {
  2163.                 txt barlen [() xpos textpos textfont textsize] put
  2164.             } ifelse
  2165.             sbs barlen 6 mul 12 add encs 11 get putinterval
  2166.         } ifelse
  2167.     } {
  2168.         sbs barlen 6 mul 6 add encs 11 get putinterval
  2169.     } ifelse
  2170.  
  2171.     % Return the arguments
  2172.     /retval 1 dict def
  2173.     retval (sbs) [sbs {48 sub} forall] put
  2174.     retval (bhs) [sbs length 1 add 2 idiv {height} repeat] put
  2175.     retval (bbs) [sbs length 1 add 2 idiv {0} repeat] put
  2176.     includetext {
  2177.         retval (txt) txt put
  2178.     } if
  2179.     retval (opt) useropts put
  2180.     retval
  2181.  
  2182.     end
  2183.  
  2184. } bind def
  2185. /code11 load 0 1 dict put
  2186. % --END ENCODER code11--
  2187.  
  2188. % --BEGIN ENCODER rationalizedCodabar--
  2189. % --DESC: Rationalized Codabar
  2190. % --EXAM: A0123456789B
  2191. /rationalizedCodabar {
  2192.  
  2193.     0 begin                    % Confine variables to local scope
  2194.  
  2195.     /options exch def          % We are given an option string
  2196.     /useropts options def
  2197.     /barcode exch def          % We are given a barcode string
  2198.  
  2199.     /includecheck false def     % Enable/disable checkdigit
  2200.     /includetext false def      % Enable/disable text
  2201.     /includecheckintext false def
  2202.     /textfont /Courier def
  2203.     /textsize 10 def
  2204.     /textpos -7 def
  2205.     /height 1 def
  2206.     
  2207.     % Parse the input options
  2208.     options {
  2209.         token false eq {exit} if dup length string cvs (=) search
  2210.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  2211.     } loop
  2212.     
  2213.     /textfont textfont cvlit def
  2214.     /textsize textsize cvr def
  2215.     /textpos textpos cvr def
  2216.     /height height cvr def
  2217.     
  2218.     % Create an array containing the character mappings
  2219.     /encs
  2220.     [ (11111331) (11113311) (11131131) (33111111) (11311311)
  2221.       (31111311) (13111131) (13113111) (13311111) (31131111)
  2222.       (11133111) (11331111) (31113131) (31311131) (31313111)
  2223.       (11313131) (11331311) (13131131) (11131331) (11133311)
  2224.     ] def
  2225.  
  2226.     % Create a string of the available characters
  2227.     /barchars (0123456789-$:/.+ABCD) def
  2228.  
  2229.     /barlen barcode length def    % Length of the code
  2230.  
  2231.     includecheck {
  2232.         /sbs barlen 8 mul 8 add string def
  2233.         /txt barlen 1 add array def
  2234.     } {
  2235.         /sbs barlen 8 mul string def
  2236.         /txt barlen array def
  2237.     } ifelse
  2238.  
  2239.     /checksum 0 def
  2240.     /xpos 0 def
  2241.     0 1 barlen 2 sub {
  2242.         /i exch def
  2243.         % Lookup the encoding for the each barcode character
  2244.         barcode i 1 getinterval barchars exch search
  2245.         pop                          % Discard true leaving pre
  2246.         length /indx exch def        % indx is the length of pre
  2247.         pop pop                      % Discard seek and post
  2248.         /enc encs indx get def       % Get the indxth encoding
  2249.         sbs i 8 mul enc putinterval  % Put encoded digit into sbs
  2250.         txt i [barcode i 1 getinterval xpos textpos textfont textsize] put
  2251.         0 1 7 {       % xpos+=width of the character
  2252.             /xpos exch enc exch get 48 sub xpos add def
  2253.         } for
  2254.         /checksum checksum indx add def
  2255.     } for
  2256.  
  2257.     % Find index of last character
  2258.     barcode barlen 1 sub 1 getinterval barchars exch search
  2259.     pop                          % Discard true leaving pre
  2260.     length /indx exch def        % indx is the length of pre
  2261.     pop pop                      % Discard seek and post
  2262.  
  2263.     includecheck {
  2264.         % Put the checksum character
  2265.         /checksum checksum indx add def
  2266.         /checksum 16 checksum 16 mod sub 16 mod def
  2267.         sbs barlen 8 mul 8 sub encs checksum get putinterval
  2268.         includecheckintext {
  2269.             txt barlen 1 sub [barchars checksum 1 getinterval xpos textpos textfont textsize] put
  2270.         } {
  2271.             txt barlen 1 sub [( ) xpos textpos textfont textsize] put
  2272.         } ifelse
  2273.         0 1 7 {       % xpos+=width of the character
  2274.             /xpos exch encs checksum get exch get 48 sub xpos add def
  2275.         } for
  2276.         % Put the end character
  2277.         /enc encs indx get def            % Get the indxth encoding
  2278.         sbs barlen 8 mul enc putinterval  % Put encoded digit into sbs
  2279.         txt barlen [barcode barlen 1 sub 1 getinterval xpos textpos textfont textsize] put
  2280.     } {
  2281.         % Put the end character
  2282.         /enc encs indx get def                  % Get the indxth encoding
  2283.         sbs barlen 8 mul 8 sub enc putinterval  % Put encoded digit into sbs
  2284.         txt barlen 1 sub [barcode barlen 1 sub 1 getinterval xpos textpos textfont textsize] put
  2285.     } ifelse
  2286.  
  2287.     % Return the arguments
  2288.     /retval 1 dict def
  2289.     retval (sbs) [sbs {48 sub} forall] put
  2290.     retval (bhs) [sbs length 1 add 2 idiv {height} repeat] put
  2291.     retval (bbs) [sbs length 1 add 2 idiv {0} repeat] put
  2292.     includetext {
  2293.         retval (txt) txt put
  2294.     } if
  2295.     retval (opt) useropts put
  2296.     retval
  2297.  
  2298.     end
  2299.  
  2300. } bind def
  2301. /rationalizedCodabar load 0 1 dict put
  2302. % --END ENCODER rationalizedCodabar--
  2303.  
  2304. % --BEGIN ENCODER onecode--
  2305. % --DESC: United States Postal Service OneCode
  2306. % --EXAM: 0123456709498765432101234567891
  2307. /onecode {
  2308.  
  2309.     0 begin
  2310.  
  2311.     /options exch def              % We are given an option string
  2312.     /useropts options def
  2313.     /barcode exch def              % We are given a barcode string
  2314.  
  2315.     /height 0.175 def
  2316.     
  2317.     % Parse the input options
  2318.     options {
  2319.         token false eq {exit} if dup length string cvs (=) search
  2320.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  2321.     } loop
  2322.     
  2323.     /height height cvr def
  2324.  
  2325.     /barlen barcode length def
  2326.  
  2327.     /normalize {
  2328.         /base exch def
  2329.         /num exch def
  2330.         num length 1 sub -1 1 {
  2331.             /i exch def        
  2332.             num i 1 sub 2 copy get num i get base idiv add put
  2333.             num i num i get base mod put
  2334.         } for
  2335.         { %loop - extend input as necessary
  2336.             num 0 get base lt {exit} if
  2337.             /num [0 num {} forall] def        
  2338.             num 0 num 0 get num 1 get base idiv add put
  2339.             num 1 num 1 get base mod put
  2340.         } loop
  2341.         % Trim leading zeros
  2342.         /num [/i true def num {dup 0 eq i and {pop} {/i false def} ifelse} forall] def   
  2343.         num length 0 eq {/num [0] def} if
  2344.         num
  2345.     } bind def
  2346.  
  2347.     /bigadd {
  2348.         2 copy length exch length
  2349.         2 copy sub abs /offset exch def
  2350.         lt {exch} if
  2351.         /a exch def /b exch def    
  2352.         0 1 b length 1 sub {
  2353.             dup a exch offset add 2 copy get b 5 -1 roll get add put
  2354.         } for
  2355.         a
  2356.     } bind def
  2357.  
  2358.     % Conversion of data fields into binary data
  2359.     barlen 20 eq {[0]} if
  2360.     barlen 25 eq {[1]} if
  2361.     barlen 29 eq {[1 0 0 0 0 1]} if
  2362.     barlen 31 eq {[1 0 0 0 1 0 0 0 0 1]} if
  2363.     /binval exch [barcode 20 barlen 20 sub getinterval {48 sub} forall] bigadd def
  2364.     /binval [binval {} forall barcode 0 get 48 sub] def
  2365.     /binval [binval {5 mul} forall] [barcode 1 get 48 sub] bigadd 10 normalize def
  2366.     /binval [binval {} forall barcode 2 18 getinterval {48 sub} forall] def
  2367.  
  2368.     % Conversion of binary data into byte array
  2369.     /bytes 13 array def
  2370.     /bintmp [binval {} forall] def
  2371.     12 -1 0 {
  2372.         /i exch def
  2373.         0 1 bintmp length 2 sub {
  2374.             /j exch def
  2375.             bintmp j 1 add 2 copy get bintmp j get 256 mod 10 mul add put
  2376.             bintmp j bintmp j get 256 idiv put
  2377.         } for
  2378.         bytes i bintmp bintmp length 1 sub get 256 mod put
  2379.         bintmp bintmp length 1 sub 2 copy get 256 idiv put    
  2380.     } for
  2381.  
  2382.     % Generation of 11-bit CRC on byte array
  2383.     /fcs 2047 def
  2384.     /dat bytes 0 get 5 bitshift def
  2385.     6 {
  2386.         fcs dat xor 1024 and 0 ne {
  2387.             /fcs fcs 1 bitshift 3893 xor def 
  2388.         } {
  2389.             /fcs fcs 1 bitshift def
  2390.         } ifelse
  2391.         /fcs fcs 2047 and def
  2392.         /dat dat 1 bitshift def
  2393.     } repeat
  2394.     1 1 12 {
  2395.         bytes exch get 3 bitshift /dat exch def    
  2396.         8 {        
  2397.             fcs dat xor 1024 and 0 ne {
  2398.                 /fcs fcs 1 bitshift 3893 xor def 
  2399.             } {
  2400.                 /fcs fcs 1 bitshift def
  2401.             } ifelse
  2402.             /fcs fcs 2047 and def
  2403.             /dat dat 1 bitshift def
  2404.         } repeat
  2405.     } for
  2406.  
  2407.     % Conversion from binary data to codewords
  2408.     /codewords 10 array def
  2409.     9 -1 0 {
  2410.         /i exch def
  2411.         i 9 eq {
  2412.             /b 636 def
  2413.         } {
  2414.             /b 1365 def
  2415.         } ifelse
  2416.         0 1 binval length 2 sub {
  2417.             /j exch def
  2418.             binval j 1 add 2 copy get binval j get b mod 10 mul add put
  2419.             binval j binval j get b idiv put
  2420.         } for   
  2421.         codewords i binval binval length 1 sub get b mod put
  2422.         binval binval length 1 sub 2 copy get b idiv put
  2423.     } for
  2424.  
  2425.     % Inserting additional information into codewords
  2426.     codewords 9 codewords 9 get 2 mul put
  2427.     fcs 1024 and 0 ne {
  2428.         codewords 0 codewords 0 get 659 add put
  2429.     } if
  2430.  
  2431.     % Conversion from codewords to characters
  2432.     /tab513 1287 dict def
  2433.     /lo 0 def
  2434.     /hi 1286 def
  2435.     0 1 8191 {   
  2436.         { % no loop - provides common exit point
  2437.             /i exch def
  2438.             /onbits 0 def
  2439.             0 1 12 {           
  2440.                 i exch 1 exch bitshift and 0 ne {
  2441.                     /onbits onbits 1 add def
  2442.                 } if
  2443.             } for
  2444.             onbits 5 ne {exit} if
  2445.             /j i def
  2446.             /rev 0 def
  2447.             16 {            
  2448.                 /rev rev 1 bitshift j 1 and or def
  2449.                 /j j -1 bitshift def                
  2450.             } repeat          
  2451.             /rev rev -3 bitshift def            
  2452.             rev i lt {exit} if
  2453.             rev i eq {
  2454.                 tab513 hi i put
  2455.                 /hi hi 1 sub def
  2456.             } {
  2457.                 tab513 lo i put
  2458.                 tab513 lo 1 add rev put
  2459.                 /lo lo 2 add def                      
  2460.             } ifelse
  2461.             exit
  2462.         } loop
  2463.     } for
  2464.  
  2465.     /tab213 78 dict def
  2466.     /lo 0 def
  2467.     /hi 77 def
  2468.     0 1 8191 {   
  2469.         { % no loop - provides common exit point
  2470.             /i exch def
  2471.             /onbits 0 def
  2472.             0 1 12 {           
  2473.                 i exch 1 exch bitshift and 0 ne {
  2474.                     /onbits onbits 1 add def
  2475.                 } if
  2476.             } for
  2477.             onbits 2 ne {exit} if
  2478.             /j i def
  2479.             /rev 0 def
  2480.             16 {            
  2481.                 /rev rev 1 bitshift j 1 and or def
  2482.                 /j j -1 bitshift def                
  2483.             } repeat          
  2484.             /rev rev -3 bitshift def            
  2485.             rev i lt {exit} if
  2486.             rev i eq {
  2487.                 tab213 hi i put
  2488.                 /hi hi 1 sub def
  2489.             } {
  2490.                 tab213 lo i put
  2491.                 tab213 lo 1 add rev put
  2492.                 /lo lo 2 add def                      
  2493.             } ifelse
  2494.             exit
  2495.         } loop
  2496.     } for
  2497.  
  2498.     /chars 10 array def
  2499.     0 1 9 {
  2500.         /i exch def
  2501.         codewords i get dup 1286 le {
  2502.             tab513 exch get 
  2503.         } {
  2504.             tab213 exch 1287 sub get
  2505.         } ifelse
  2506.         chars i 3 -1 roll put
  2507.     } for
  2508.  
  2509.     9 -1 0 {
  2510.         /i exch def
  2511.         2 i exp cvi fcs and 0 ne {
  2512.             chars i chars i get 8191 xor put
  2513.         } if
  2514.     } for
  2515.  
  2516.     % Conversion from characters to the OneCode encoding
  2517.     /barmap [
  2518.         7 2 4 3    1 10 0 0   9 12 2 8   5 5 6 11   8 9 3 1
  2519.         0 1 5 12   2 5 1 8    4 4 9 11   6 3 8 10   3 9 7 6
  2520.         5 11 1 4   8 5 2 12   9 10 0 2   7 1 6 7    3 6 4 9
  2521.         0 3 8 6    6 4 2 7    1 1 9 9    7 10 5 2   4 0 3 8
  2522.         6 2 0 4    8 11 1 0   9 8 3 12   2 6 7 7    5 1 4 10
  2523.         1 12 6 9   7 3 8 0    5 8 9 7    4 6 2 10   3 4 0 5
  2524.         8 4 5 7    7 11 1 9   6 0 9 6    0 6 4 8    2 1 3 2
  2525.         5 9 8 12   4 11 6 1   9 5 7 4    3 3 1 2    0 7 2 0
  2526.         1 3 4 1    6 10 3 5   8 7 9 4    2 11 5 6   0 8 7 12
  2527.         4 2 8 1    5 10 3 0   9 3 0 9    6 5 2 4    7 8 1 7
  2528.         5 0 4 5    2 3 0 10   6 12 9 2   3 11 1 6   8 8 7 9
  2529.         5 4 0 11   1 5 2 2    9 1 4 12   8 3 6 6    7 0 3 7
  2530.         4 7 7 5    0 12 1 11  2 9 9 0    6 8 5 3    3 10 8 2
  2531.     ] def
  2532.  
  2533.     /bbs 65 array def    
  2534.     /bhs 65 array def
  2535.     0 1 64 {
  2536.         /i exch def
  2537.         /dec chars barmap i 4 mul get get 2 barmap i 4 mul 1 add get exp cvi and 0 ne def
  2538.         /asc chars barmap i 4 mul 2 add get get 2 barmap i 4 mul 3 add get exp cvi and 0 ne def
  2539.         dec not asc not and {
  2540.             bbs i 3 height mul 8 div put
  2541.             bhs i 2 height mul 8 div put
  2542.         } if
  2543.         dec not asc and {
  2544.             bbs i 3 height mul 8 div put
  2545.             bhs i 5 height mul 8 div put        
  2546.         } if
  2547.         dec asc not and {
  2548.             bbs i 0 height mul 8 div put
  2549.             bhs i 5 height mul 8 div put        
  2550.         } if
  2551.         dec asc and {
  2552.             bbs i 0 height mul 8 div put
  2553.             bhs i 8 height mul 8 div put        
  2554.         } if
  2555.     } for
  2556.     
  2557.     /retval 4 dict def
  2558.     retval (bbs) bbs put
  2559.     retval (bhs) bhs put
  2560.     retval (sbs) [bhs length 1 sub {1.44 1.872} repeat 1.44] put    
  2561.     retval (opt) useropts put
  2562.     retval
  2563.  
  2564.     end
  2565.  
  2566. } bind def
  2567. /onecode load 0 1 dict put
  2568. % --END ENCODER onecode--
  2569.  
  2570. % --BEGIN ENCODER postnet--
  2571. % --DESC: United States Postal Service Postnet
  2572. % --EXAM: 012345
  2573. /postnet {
  2574.  
  2575.     % Thanks to Ross McFarland
  2576.  
  2577.     0 begin
  2578.  
  2579.     /options exch def              % We are given an option string
  2580.     /useropts options def
  2581.     /barcode exch def              % We are given a barcode string
  2582.  
  2583.     /includetext false def          % Enable/disable text
  2584.     /includecheckintext false def
  2585.     /textfont /Courier def
  2586.     /textsize 10 def
  2587.     /textpos -7 def
  2588.     /height 0.125 def
  2589.     
  2590.     % Parse the input options
  2591.     options {
  2592.         token false eq {exit} if dup length string cvs (=) search
  2593.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  2594.     } loop
  2595.     
  2596.     /textfont textfont cvlit def
  2597.     /textsize textsize cvr def
  2598.     /textpos textpos cvr def
  2599.     /height height cvr def
  2600.     
  2601.     /barlen barcode length def
  2602.  
  2603.     % Create an array containing the character mappings
  2604.     /encs
  2605.     [ (55222) (22255) (22525) (22552) (25225)
  2606.       (25252) (25522) (52225) (52252) (52522)
  2607.       (5) (5)
  2608.     ] def
  2609.  
  2610.     % Create a string of the available characters
  2611.     /barchars (0123456789) def
  2612.  
  2613.     /bhs barlen 5 mul 7 add array def
  2614.     /txt barlen 1 add array def
  2615.  
  2616.     % Put start character
  2617.     /enc encs 10 get def
  2618.     /heights enc length array def
  2619.     0 1 enc length 1 sub {
  2620.         /j exch def
  2621.         heights j enc j 1 getinterval cvi height mul 5 div put
  2622.     } for
  2623.     bhs 0 heights putinterval   % Put encoded digit into sbs
  2624.  
  2625.     /checksum 0 def
  2626.     0 1 barlen 1 sub {
  2627.         /i exch def
  2628.         % Lookup the encoding for the each barcode character
  2629.         barcode i 1 getinterval barchars exch search
  2630.         pop                                 % Discard true leaving pre
  2631.         length /indx exch def               % indx is the length of pre
  2632.         pop pop                             % Discard seek and post
  2633.         /enc encs indx get def              % Get the indxth encoding
  2634.         /heights enc length array def
  2635.         0 1 enc length 1 sub {
  2636.             /j exch def
  2637.             heights j enc j 1 getinterval cvi height mul 5 div put
  2638.         } for
  2639.         bhs i 5 mul 1 add heights putinterval   % Put encoded digit into sbs
  2640.         txt i [barcode i 1 getinterval i 5 mul 1 add 3.312 mul textpos textfont textsize] put
  2641.         /checksum checksum indx add def     % checksum+=indx
  2642.     } for
  2643.  
  2644.     % Put the checksum character
  2645.     /checksum 10 checksum 10 mod sub 10 mod def
  2646.     /enc encs checksum get def
  2647.     /heights enc length array def
  2648.     0 1 enc length 1 sub {
  2649.         /j exch def
  2650.         heights j enc j 1 getinterval cvi height mul 5 div put
  2651.     } for
  2652.     bhs barlen 5 mul 1 add heights putinterval  
  2653.     
  2654.     includecheckintext {
  2655.         txt barlen [barchars checksum 1 getinterval barlen 5 mul 1 add 3.312 mul textpos textfont textsize] put
  2656.     } {
  2657.         txt barlen [( ) barlen 5 mul 1 add 72 mul 25 div textpos textfont textsize] put
  2658.     } ifelse
  2659.     
  2660.     % Put end character
  2661.     /enc encs 11 get def
  2662.     /heights enc length array def
  2663.     0 1 enc length 1 sub {
  2664.         /j exch def
  2665.         heights j enc j 1 getinterval cvi height mul 5 div put
  2666.     } for
  2667.     bhs barlen 5 mul 6 add heights putinterval  
  2668.  
  2669.     /retval 1 dict def
  2670.     retval (bhs) bhs put
  2671.     retval (bbs) [bhs length {0} repeat] put
  2672.     retval (sbs) [bhs length 1 sub {1.44 1.872} repeat 1.44] put
  2673.     includetext {
  2674.         retval (txt) txt put
  2675.     } if
  2676.     retval (opt) useropts put
  2677.     retval
  2678.  
  2679.     end
  2680.  
  2681. } bind def
  2682. /postnet load 0 1 dict put
  2683. % --END ENCODER postnet--
  2684.  
  2685. % --BEGIN ENCODER royalmail--
  2686. % --DESC: Royal Mail 4 State Customer Code (RM4SCC)
  2687. % --EXAM: LE28HS9Z
  2688. /royalmail {
  2689.  
  2690.     0 begin
  2691.  
  2692.     /options exch def              % We are given an option string
  2693.     /useropts options def
  2694.     /barcode exch def              % We are given a barcode string
  2695.  
  2696.     /includetext false def          % Enable/disable text
  2697.     /includecheckintext false def
  2698.     /textfont /Courier def
  2699.     /textsize 10 def
  2700.     /textpos -7 def
  2701.     /height 0.175 def
  2702.     
  2703.     % Parse the input options
  2704.     options {
  2705.         token false eq {exit} if dup length string cvs (=) search
  2706.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  2707.     } loop
  2708.     
  2709.     /textfont textfont cvlit def
  2710.     /textsize textsize cvr def
  2711.     /textpos textpos cvr def
  2712.     /height height cvr def
  2713.     
  2714.     % Create an array containing the character mappings
  2715.     /encs
  2716.     [ (3300) (2211) (2301) (2310) (3201) (3210) 
  2717.       (1122) (0033) (0123) (0132) (1023) (1032) 
  2718.       (1302) (0213) (0303) (0312) (1203) (1212) 
  2719.       (1320) (0231) (0321) (0330) (1221) (1230) 
  2720.       (3102) (2013) (2103) (2112) (3003) (3012) 
  2721.       (3120) (2031) (2121) (2130) (3021) (3030) 
  2722.       (2) (3)
  2723.     ] def
  2724.  
  2725.     % Create a string of the available characters
  2726.     /barchars (ZUVWXY501234B6789AHCDEFGNIJKLMTOPQRS) def
  2727.  
  2728.     /barlen barcode length def
  2729.     /encstr barlen 4 mul 6 add string def
  2730.     /txt barlen 1 add array def
  2731.  
  2732.     % Put start character
  2733.     encstr 0 encs 36 get putinterval
  2734.     
  2735.     /checksumrow 0 def
  2736.     /checksumcol 0 def
  2737.     0 1 barlen 1 sub {
  2738.         /i exch def
  2739.         % Lookup the encoding for the each barcode character
  2740.         barcode i 1 getinterval barchars exch search
  2741.         pop                                 % Discard true leaving pre
  2742.         length /indx exch def               % indx is the length of pre
  2743.         pop pop                             % Discard seek and post
  2744.         /enc encs indx get def              % Get the indxth encoding
  2745.         encstr i 4 mul 1 add enc putinterval
  2746.         txt i [barcode i 1 getinterval i 4 mul 1 add 3.312 mul textpos textfont textsize] put
  2747.         /checksumrow checksumrow indx 6 idiv add def
  2748.         /checksumcol checksumcol indx 6 mod add def 
  2749.     } for
  2750.  
  2751.     % Put the checksum character
  2752.     /checksum checksumrow 6 mod 6 mul checksumcol 6 mod add def
  2753.     /enc encs checksum get def
  2754.     encstr barlen 4 mul 1 add enc putinterval
  2755.     includecheckintext {
  2756.         txt barlen [barchars checksum 1 getinterval barlen 4 mul 1 add 3.312 mul textpos textfont textsize] put
  2757.     } {
  2758.         txt barlen [( ) barlen 4 mul 1 add 3.312 mul textpos textfont textsize] put
  2759.     } ifelse
  2760.     
  2761.     % Put end character
  2762.     encstr barlen 4 mul 5 add encs 37 get putinterval  
  2763.  
  2764.     /bbs encstr length array def    
  2765.     /bhs encstr length array def
  2766.     0 1 encstr length 1 sub {
  2767.         /i exch def
  2768.         /enc encstr i 1 getinterval def
  2769.         enc (0) eq {
  2770.             bbs i 3 height mul 8 div put
  2771.             bhs i 2 height mul 8 div put
  2772.         } if
  2773.         enc (1) eq {
  2774.             bbs i 0 height mul 8 div put
  2775.             bhs i 5 height mul 8 div put
  2776.         } if
  2777.         enc (2) eq {
  2778.             bbs i 3 height mul 8 div put
  2779.             bhs i 5 height mul 8 div put
  2780.         } if
  2781.         enc (3) eq {
  2782.             bbs i 0 height mul 8 div put
  2783.             bhs i 8 height mul 8 div put
  2784.         } if
  2785.     } for
  2786.     
  2787.     /retval 4 dict def
  2788.     retval (bbs) bbs put
  2789.     retval (bhs) bhs put
  2790.     retval (sbs) [bhs length 1 sub {1.44 1.872} repeat 1.44] put
  2791.     includetext {
  2792.         retval (txt) txt put
  2793.     } if
  2794.     retval (opt) useropts put
  2795.     retval
  2796.  
  2797.     end
  2798.  
  2799. } bind def
  2800. /royalmail load 0 1 dict put
  2801. % --END ENCODER royalmail--
  2802.  
  2803. % --BEGIN ENCODER auspost--
  2804. % --DESC: AusPost 4 State Customer Code
  2805. % --EXAM: 5956439111ABA 9
  2806. /auspost {
  2807.  
  2808.     0 begin
  2809.  
  2810.     /options exch def              % We are given an option string
  2811.     /useropts options def
  2812.     /barcode exch def              % We are given a barcode string
  2813.  
  2814.     /includetext false def         % Enable/disable text
  2815.     /textfont /Courier def
  2816.     /textsize 10 def
  2817.     /textpos -7 def
  2818.     /height 0.175 def
  2819.     /custinfoenc (character) def
  2820.     
  2821.     % Parse the input options
  2822.     options {
  2823.         token false eq {exit} if dup length string cvs (=) search
  2824.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  2825.     } loop
  2826.     
  2827.     /textfont textfont cvlit def
  2828.     /textsize textsize cvr def
  2829.     /textpos textpos cvr def
  2830.     /height height cvr def
  2831.  
  2832.     % Create an array containing the character mappings
  2833.     /encs
  2834.     [ (000) (001) (002) (010) (011) (012) (020) (021)
  2835.       (022) (100) (101) (102) (110) (111) (112) (120)
  2836.       (121) (122) (200) (201) (202) (210) (211) (212)
  2837.       (220) (221) (222) (300) (301) (302) (310) (311)
  2838.       (312) (320) (321) (322) (023) (030) (031) (032)
  2839.       (033) (103) (113) (123) (130) (131) (132) (133)
  2840.       (203) (213) (223) (230) (231) (232) (233) (303)
  2841.       (313) (323) (330) (331) (332) (333) (003) (013)
  2842.       (00) (01) (02) (10) (11) (12) (20) (21) (22) (30)
  2843.       (13) (3)
  2844.     ] def
  2845.  
  2846.     % Create a string of the available characters
  2847.     /barchars (ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz #) def
  2848.     
  2849.     /barlen barcode length def
  2850.     barcode 0 2 getinterval (11) eq {37} if
  2851.     barcode 0 2 getinterval (59) eq {52} if
  2852.     barcode 0 2 getinterval (62) eq {67} if
  2853.     /encstr exch string def
  2854.     /txt barlen 2 sub array def
  2855.  
  2856.     % Put start character
  2857.     encstr 0 encs 74 get putinterval
  2858.  
  2859.     % Encode the FCC
  2860.     0 1 1 {
  2861.         /i exch def       
  2862.         encs barcode i 1 getinterval cvi 64 add get
  2863.         encstr i 2 mul 2 add 3 2 roll putinterval
  2864.     } for
  2865.     
  2866.     % Encode the DPID
  2867.     2 1 9 {
  2868.         /i exch def       
  2869.         encs barcode i 1 getinterval cvi 64 add get
  2870.         encstr i 2 mul 2 add 3 2 roll putinterval
  2871.         txt i 2 sub [barcode i 1 getinterval i 2 sub 2 mul 6 add 3.312 mul textpos textfont textsize] put
  2872.     } for
  2873.     
  2874.     % Encode the customer information   
  2875.     custinfoenc (numeric) eq {
  2876.         0 1 barlen 11 sub {
  2877.             /i exch def
  2878.             encs barcode i 10 add 1 getinterval cvi 64 add get
  2879.             encstr i 2 mul 22 add 3 2 roll putinterval
  2880.             txt i 8 add [barcode i 10 add 1 getinterval i 2 mul 22 add 3.312 mul textpos textfont textsize] put
  2881.         } for        
  2882.         /ciflen barlen 10 sub 2 mul def
  2883.     } {
  2884.         0 1 barlen 11 sub {
  2885.             /i exch def           
  2886.             barcode i 10 add 1 getinterval barchars exch search
  2887.             pop                                
  2888.             length /indx exch def           
  2889.             pop pop                            
  2890.             /enc encs indx get def          
  2891.             encstr i 3 mul 22 add enc putinterval
  2892.             txt i 8 add [barcode i 10 add 1 getinterval i 3 mul 22 add 3.312 mul textpos textfont textsize] put
  2893.         } for        
  2894.         /ciflen barlen 10 sub 3 mul def
  2895.     } ifelse
  2896.  
  2897.     % Add any filler characters
  2898.     22 ciflen add 1 encstr length 14 sub {        
  2899.         encstr exch encs 75 get putinterval
  2900.     } for
  2901.     
  2902.     % Create the 64x64 Reed-Solomon table
  2903.     /rstable 64 64 mul array def
  2904.     rstable 0 [ 64 {0} repeat ] putinterval
  2905.     rstable 64 [ 0 1 63 {} for ] putinterval
  2906.     /prev 1 def
  2907.     64 {       
  2908.         /next prev 1 bitshift def
  2909.         next 64 and 0 ne {
  2910.             /next next 67 xor def
  2911.         } if        
  2912.         0 1 63 {
  2913.             /j exch def
  2914.             /nextcell {rstable 64 next mul j add} def
  2915.             nextcell rstable 64 prev mul j add get 1 bitshift put
  2916.             nextcell get 64 and 0 ne {
  2917.                 nextcell nextcell get 67 xor put
  2918.             } if
  2919.         } for
  2920.         /prev next def
  2921.     } repeat
  2922.     
  2923.     % Calculate the Reed-Solomon codes for triples
  2924.     /rscodes encstr length 16 sub 3 idiv 4 add array def
  2925.     rscodes 0 [ 4 {0} repeat ] putinterval
  2926.     2 3 encstr length 16 sub {
  2927.         /i exch def
  2928.         rscodes rscodes length i 2 sub 3 idiv sub 1 sub
  2929.         encstr i 1 getinterval cvi 16 mul
  2930.         encstr i 1 add 1 getinterval cvi 4 mul add
  2931.         encstr i 2 add 1 getinterval cvi add        
  2932.         put
  2933.     } for    
  2934.     rscodes length 5 sub -1 0 {
  2935.        /i exch def
  2936.        0 1 4 {
  2937.            /j exch def
  2938.            rscodes i j add rscodes i j add get
  2939.            rstable 64 [48 17 29 30 1] j get mul rscodes i 4 add get add get
  2940.            xor put
  2941.        } for
  2942.     } for
  2943.     /checkcode (000000000000) def
  2944.     0 1 3 {
  2945.         /i exch def
  2946.         /enc rscodes 3 i sub get 4 3 string cvrs def
  2947.         checkcode i 3 mul 3 enc length sub add enc putinterval
  2948.     } for
  2949.     
  2950.     % Put checkcode and end characters
  2951.     encstr encstr length 14 sub checkcode putinterval
  2952.     encstr encstr length 2 sub encs 74 get putinterval 
  2953.  
  2954.     /bbs encstr length array def    
  2955.     /bhs encstr length array def
  2956.     0 1 encstr length 1 sub {
  2957.         /i exch def
  2958.         /enc encstr i 1 getinterval def
  2959.         enc (0) eq {
  2960.             bbs i 0 height mul 8 div put
  2961.             bhs i 8 height mul 8 div put
  2962.         } if
  2963.         enc (1) eq {
  2964.             bbs i 3 height mul 8 div put
  2965.             bhs i 5 height mul 8 div put
  2966.         } if
  2967.         enc (2) eq {
  2968.             bbs i 0 height mul 8 div put
  2969.             bhs i 5 height mul 8 div put
  2970.         } if
  2971.         enc (3) eq {
  2972.             bbs i 3 height mul 8 div put
  2973.             bhs i 2 height mul 8 div put
  2974.         } if
  2975.     } for   
  2976.     
  2977.     /retval 4 dict def
  2978.     retval (bbs) bbs put
  2979.     retval (bhs) bhs put
  2980.     retval (sbs) [bhs length 1 sub {1.44 1.872} repeat 1.44] put
  2981.     includetext {
  2982.         retval (txt) txt put
  2983.     } if
  2984.     retval (opt) useropts put
  2985.     retval
  2986.  
  2987.     end
  2988.  
  2989. } bind def
  2990. /auspost load 0 1 dict put
  2991. % --END ENCODER auspost--
  2992.  
  2993. % --BEGIN ENCODER kix--
  2994. % --DESC: Royal Dutch TPG Post KIX 4-State Barcode
  2995. % --EXAM: 1231FZ13XHS
  2996. /kix {
  2997.  
  2998.     0 begin
  2999.  
  3000.     /options exch def              % We are given an option string
  3001.     /useropts options def
  3002.     /barcode exch def              % We are given a barcode string
  3003.  
  3004.     /includetext false def          % Enable/disable text
  3005.     /includecheckintext false def
  3006.     /textfont /Courier def
  3007.     /textsize 10 def
  3008.     /textpos -7 def
  3009.     /height 0.175 def
  3010.     
  3011.     % Parse the input options
  3012.     options {
  3013.         token false eq {exit} if dup length string cvs (=) search
  3014.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  3015.     } loop
  3016.     
  3017.     /textfont textfont cvlit def
  3018.     /textsize textsize cvr def
  3019.     /textpos textpos cvr def
  3020.     /height height cvr def
  3021.     
  3022.     % Create an array containing the character mappings
  3023.     /encs
  3024.     [ (0033) (0123) (0132) (1023) (1032) (1122)
  3025.       (0213) (0303) (0312) (1203) (1212) (1302) 
  3026.       (0231) (0321) (0330) (1221) (1230) (1320)
  3027.       (2013) (2103) (2112) (3003) (3012) (3102)
  3028.       (2031) (2121) (2130) (3021) (3030) (3120) 
  3029.       (2211) (2301) (2310) (3201) (3210) (3300) 
  3030.     ] def
  3031.  
  3032.     % Create a string of the available characters
  3033.     /barchars (0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ) def
  3034.  
  3035.     /barlen barcode length def
  3036.     /encstr barlen 4 mul string def
  3037.     /txt barlen array def
  3038.     
  3039.     0 1 barlen 1 sub {
  3040.         /i exch def
  3041.         % Lookup the encoding for the each barcode character
  3042.         barcode i 1 getinterval barchars exch search
  3043.         pop                                 % Discard true leaving pre
  3044.         length /indx exch def               % indx is the length of pre
  3045.         pop pop                             % Discard seek and post
  3046.         /enc encs indx get def              % Get the indxth encoding
  3047.         encstr i 4 mul enc putinterval
  3048.         txt i [barcode i 1 getinterval i 4 mul 3.312 mul textpos textfont textsize] put
  3049.     } for
  3050.  
  3051.     /bbs encstr length array def    
  3052.     /bhs encstr length array def
  3053.     0 1 encstr length 1 sub {
  3054.         /i exch def
  3055.         /enc encstr i 1 getinterval def
  3056.         enc (0) eq {
  3057.             bbs i 3 height mul 8 div put
  3058.             bhs i 2 height mul 8 div put
  3059.         } if
  3060.         enc (1) eq {
  3061.             bbs i 0 height mul 8 div put
  3062.             bhs i 5 height mul 8 div put
  3063.         } if
  3064.         enc (2) eq {
  3065.             bbs i 3 height mul 8 div put
  3066.             bhs i 5 height mul 8 div put
  3067.         } if
  3068.         enc (3) eq {
  3069.             bbs i 0 height mul 8 div put
  3070.             bhs i 8 height mul 8 div put
  3071.         } if
  3072.     } for
  3073.     
  3074.     /retval 4 dict def
  3075.     retval (bbs) bbs put
  3076.     retval (bhs) bhs put
  3077.     retval (sbs) [bhs length 1 sub {1.44 1.872} repeat 1.44] put
  3078.     includetext {
  3079.         retval (txt) txt put
  3080.     } if
  3081.     retval (opt) useropts put
  3082.     retval
  3083.  
  3084.     end
  3085.  
  3086. } bind def
  3087. /kix load 0 1 dict put
  3088. % --END ENCODER kix--
  3089.  
  3090. % --BEGIN ENCODER msi--
  3091. % --DESC: MSI Modified Plessey
  3092. % --EXAM: 0123456789
  3093. /msi {
  3094.  
  3095.     0 begin                 % Confine variables to local scope
  3096.  
  3097.     /options exch def       % We are given an option string
  3098.     /useropts options def
  3099.     /barcode exch def       % We are given a barcode string
  3100.  
  3101.     /includecheck false def  % Enable/disable checkdigit
  3102.     /includetext false def   % Enable/disable text
  3103.     /includecheckintext false def
  3104.     /textfont /Courier def
  3105.     /textsize 10 def
  3106.     /textpos -7 def
  3107.     /height 1 def
  3108.     
  3109.     % Parse the input options
  3110.     options {
  3111.         token false eq {exit} if dup length string cvs (=) search
  3112.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  3113.     } loop
  3114.     
  3115.     /textfont textfont cvlit def
  3116.     /textsize textsize cvr def
  3117.     /textpos textpos cvr def
  3118.     /height height cvr def
  3119.     
  3120.     % Create an array containing the character mappings
  3121.     /encs
  3122.     [ (13131313) (13131331) (13133113) (13133131) (13311313)
  3123.       (13311331) (13313113) (13313131) (31131313) (31131331)
  3124.       (31) (131)
  3125.     ] def
  3126.  
  3127.     % Create a string of the available characters
  3128.     /barchars (0123456789) def
  3129.  
  3130.     /barlen barcode length def     % Length of the code
  3131.  
  3132.     includecheck {
  3133.         /sbs barlen 8 mul 13 add string def
  3134.         /txt barlen 1 add array def
  3135.     } {
  3136.         /sbs barlen 8 mul 5 add string def
  3137.         /txt barlen array def
  3138.     } ifelse
  3139.  
  3140.  
  3141.     % Put start character
  3142.     sbs 0 encs 10 get putinterval
  3143.     /checksum 0 def
  3144.  
  3145.     0 1 barlen 1 sub {
  3146.         /i exch def
  3147.         % Lookup the encoding for the each barcode character
  3148.         barcode i 1 getinterval barchars exch search
  3149.         pop                                % Discard true leaving pre
  3150.         length /indx exch def              % indx is the length of pre
  3151.         pop pop                            % Discard seek and post
  3152.         /enc encs indx get def             % Get the indxth encoding
  3153.         sbs i 8 mul 2 add enc putinterval  % Put encoded digit into sbs
  3154.         txt i [barcode i 1 getinterval i 16 mul 4 add textpos textfont textsize] put
  3155.         barlen i sub 2 mod 0 eq {
  3156.             /checksum indx checksum add def
  3157.         } {
  3158.             /checksum indx 2 mul dup 10 idiv add checksum add def
  3159.         } ifelse
  3160.     } for
  3161.  
  3162.     % Put the checksum and end characters
  3163.     includecheck {
  3164.         /checksum 10 checksum 10 mod sub 10 mod def
  3165.         sbs barlen 8 mul 2 add encs checksum get putinterval
  3166.         includecheckintext {
  3167.             txt barlen [barchars checksum 1 getinterval barlen 16 mul 4 add textpos textfont textsize] put
  3168.         } {
  3169.             txt barlen [( ) barlen 16 mul 4 add textpos textfont textsize] put
  3170.         } ifelse
  3171.         sbs barlen 8 mul 10 add encs 11 get putinterval
  3172.     } {
  3173.         sbs barlen 8 mul 2 add encs 11 get putinterval
  3174.     } ifelse
  3175.  
  3176.     % Return the arguments
  3177.     /retval 1 dict def
  3178.     retval (sbs) [sbs {48 sub} forall] put
  3179.     retval (bhs) [sbs length 1 add 2 idiv {height} repeat] put
  3180.     retval (bbs) [sbs length 1 add 2 idiv {0} repeat] put
  3181.     includetext {
  3182.         retval (txt) txt put
  3183.     } if
  3184.     retval (opt) useropts put
  3185.     retval
  3186.  
  3187.     end
  3188.  
  3189. } bind def
  3190. /msi load 0 1 dict put
  3191. % --END ENCODER msi--
  3192.  
  3193. % --BEGIN ENCODER plessey--
  3194. % --DESC: Plessey
  3195. % --EXAM: 01234ABCD
  3196. /plessey {
  3197.  
  3198.     0 begin                  % Confine variables to local scope
  3199.  
  3200.     /options exch def        % We are given an option string
  3201.     /useropts options def
  3202.     /barcode exch def        % We are given a barcode string
  3203.  
  3204.     /includetext false def    % Enable/disable text
  3205.     /includecheckintext false def
  3206.     /textfont /Courier def
  3207.     /textsize 10 def
  3208.     /textpos -7 def
  3209.     /height 1 def
  3210.     
  3211.     % Parse the input options
  3212.     options {
  3213.         token false eq {exit} if dup length string cvs (=) search
  3214.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  3215.     } loop
  3216.     
  3217.     /textfont textfont cvlit def
  3218.     /textsize textsize cvr def
  3219.     /textpos textpos cvr def
  3220.     /height height cvr def
  3221.     
  3222.     % Create an array containing the character mappings
  3223.     /encs
  3224.     [ (13131313) (31131313) (13311313) (31311313)
  3225.       (13133113) (31133113) (13313113) (31313113)
  3226.       (13131331) (31131331) (13311331) (31311331)
  3227.       (13133131) (31133131) (13313131) (31313131)
  3228.       (31311331) (331311313)
  3229.     ] def
  3230.  
  3231.     % Create a string of the available characters
  3232.     /barchars (0123456789ABCDEF) def
  3233.  
  3234.     /barlen barcode length def     % Length of the code
  3235.     /sbs barlen 8 mul 33 add string def
  3236.     /txt barlen 2 add array def
  3237.     /checkbits barlen 4 mul 8 add array def
  3238.     checkbits barlen 4 mul [ 0 0 0 0 0 0 0 0 ] putinterval
  3239.  
  3240.     % Put start character
  3241.     sbs 0 encs 16 get putinterval
  3242.  
  3243.     0 1 barlen 1 sub {
  3244.         /i exch def
  3245.         % Lookup the encoding for the each barcode character
  3246.         barcode i 1 getinterval barchars exch search
  3247.         pop                                % Discard true leaving pre
  3248.         length /indx exch def              % indx is the length of pre
  3249.         pop pop                            % Discard seek and post
  3250.         /enc encs indx get def             % Get the indxth encoding
  3251.         sbs i 8 mul 8 add enc putinterval  % Put encoded digit into sbs
  3252.         txt i [barcode i 1 getinterval i 16 mul 16 add textpos textfont textsize] put
  3253.         checkbits i 4 mul [
  3254.                 indx 1 and
  3255.                 indx -1 bitshift 1 and
  3256.                 indx -2 bitshift 1 and
  3257.                 indx -3 bitshift
  3258.         ] putinterval
  3259.     } for
  3260.  
  3261.     % Checksum is last 8 bits of a CRC using a salt
  3262.     /checksalt [ 1 1 1 1 0 1 0 0 1 ] def
  3263.     0 1 barlen 4 mul 1 sub {
  3264.         /i exch def
  3265.         checkbits i get 1 eq {
  3266.             0 1 8 {
  3267.                 /j exch def
  3268.                 checkbits i j add checkbits i j add get checksalt j get xor put
  3269.             } for
  3270.         } if
  3271.     } for
  3272.  
  3273.     % Calculate the value of the checksum digits
  3274.     /checkval 0 def
  3275.     0 1 7 {
  3276.         /i exch def
  3277.         /checkval checkval 2 7 i sub exp cvi checkbits barlen 4 mul i add get mul add def
  3278.     } for
  3279.  
  3280.     % Put the checksum characters
  3281.     /checksum1 checkval -4 bitshift def
  3282.     /checksum2 checkval 15 and def
  3283.     sbs barlen 8 mul 8 add encs checksum1 get putinterval
  3284.     sbs barlen 8 mul 16 add encs checksum2 get putinterval
  3285.     includecheckintext {
  3286.         txt barlen [barchars checksum1 1 getinterval barlen 16 mul 16 add textpos textfont textsize] put
  3287.         txt barlen 1 add [barchars checksum2 1 getinterval barlen 1 add 16 mul 16 add textpos textfont textsize] put
  3288.     } {
  3289.         txt barlen [( ) barlen 16 mul 16 add textpos textfont textsize] put
  3290.         txt barlen 1 add [( ) barlen 1 add 16 mul 16 add textpos textfont textsize] put
  3291.     } ifelse
  3292.  
  3293.     % Put end character
  3294.     sbs barlen 8 mul 24 add encs 17 get putinterval
  3295.  
  3296.     % Return the arguments
  3297.     /retval 1 dict def
  3298.     retval (sbs) [sbs {48 sub} forall] put
  3299.     retval (bhs) [sbs length 1 add 2 idiv {height} repeat] put
  3300.     retval (bbs) [sbs length 1 add 2 idiv {0} repeat] put
  3301.     includetext {
  3302.         retval (txt) txt put
  3303.     } if
  3304.     retval (opt) useropts put
  3305.     retval
  3306.  
  3307.     end
  3308.  
  3309. } bind def
  3310. /plessey load 0 1 dict put
  3311. % --END ENCODER plessey--
  3312.  
  3313. % --BEGIN ENCODER raw--
  3314. % --DESC: Raw bar space succession for custom symbologies 
  3315. % --EXAM: 331132131313411122131311333213114131131221323
  3316. /raw {
  3317.  
  3318.     0 begin                  % Confine variables to local scope
  3319.  
  3320.     /options exch def        % We are given an option string
  3321.     /useropts options def
  3322.     /sbs exch def        % We are given a barcode string
  3323.  
  3324.     /height 1 def
  3325.  
  3326.     % Parse the input options
  3327.     options {
  3328.         token false eq {exit} if dup length string cvs (=) search
  3329.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  3330.     } loop
  3331.     /height height cvr def
  3332.  
  3333.     % Return the arguments
  3334.     /retval 1 dict def
  3335.     retval (sbs) [sbs {48 sub} forall] put
  3336.     retval (bhs) [sbs length 1 add 2 idiv {height} repeat] put
  3337.     retval (bbs) [sbs length 1 add 2 idiv {0} repeat] put 
  3338.     retval (opt) useropts put
  3339.     retval
  3340.  
  3341.     end
  3342.  
  3343. } bind def
  3344. /raw load 0 1 dict put
  3345. % --END ENCODER raw--
  3346.  
  3347. % --BEGIN ENCODER symbol--
  3348. % --DESC: Miscellaneous symbols
  3349. % --EXAM: fima
  3350. /symbol {
  3351.  
  3352.     0 begin            % Confine variables to local scope
  3353.  
  3354.     /options exch def  % We are given an option string
  3355.     /barcode exch def  % We are given a barcode string
  3356.  
  3357.     barcode (fima) eq {
  3358.         /sbs [2.25 2.25 2.25 11.25 2.25 11.25 2.25 2.25 2.25] def
  3359.         /bhs [.625 .625 .625 .625 .625] def
  3360.         /bbs [0 0 0 0 0] def
  3361.     } if
  3362.  
  3363.     barcode (fimb) eq {
  3364.         /sbs [2.25 6.75 2.25 2.25 2.25 6.25 2.25 2.25 2.25 6.75 2.25] def
  3365.         /bhs [.625 .625 .625 .625 .625 .625] def
  3366.         /bbs [0 0 0 0 0 0] def
  3367.     } if
  3368.  
  3369.     barcode (fimc) eq {
  3370.         /sbs [2.25 2.25 2.25 6.75 2.25 6.75 2.25 6.75 2.25 2.25 2.25] def
  3371.         /bhs [.625 .625 .625 .625 .625 .625] def
  3372.         /bbs [0 0 0 0 0 0] def
  3373.     } if
  3374.     
  3375.     barcode (fimd) eq {
  3376.         /sbs [2.25 2.25 2.25 2.25 2.25 6.75 2.25 6.75 2.25 2.25 2.25 2.25 2.25] def
  3377.         /bhs [.625 .625 .625 .625 .625 .625 .625] def
  3378.         /bbs [0 0 0 0 0 0 0] def
  3379.     } if
  3380.     
  3381.     % Return the arguments
  3382.     /retval 4 dict def
  3383.     retval (sbs) sbs put
  3384.     retval (bhs) bhs put
  3385.     retval (bbs) bbs put
  3386.     retval (opt) options put
  3387.     retval
  3388.  
  3389.     end
  3390.  
  3391. } bind def
  3392. /symbol load 0 1 dict put
  3393. % --END ENCODER symbol--
  3394.  
  3395. % --BEGIN RENDERER--
  3396. /barcode {
  3397.  
  3398.     0 begin          % Confine variables to local scope
  3399.  
  3400.     /args exch def   % We are given some arguments
  3401.  
  3402.     % Default options
  3403.     /sbs [] def
  3404.     /bhs [] def
  3405.     /bbs [] def
  3406.     /txt [] def
  3407.     /barcolor (unset) def
  3408.     /textcolor (unset) def
  3409.     /bordercolor (unset) def
  3410.     /backgroundcolor (unset) def
  3411.     /inkspread 0.15 def
  3412.     /width 0 def
  3413.     /barratio 1 def
  3414.     /spaceratio 1 def
  3415.     /showborder false def
  3416.     /borderleft 10 def
  3417.     /borderright 10 def
  3418.     /bordertop 1 def
  3419.     /borderbottom 1 def
  3420.     /borderwidth 0.5 def
  3421.     /guardwhitespace false def
  3422.     /guardleftpos 0 def
  3423.     /guardleftypos 0 def
  3424.     /guardrightpos 0 def
  3425.     /guardrightypos 0 def
  3426.     /guardwidth 6 def
  3427.     /guardheight 7 def
  3428.     
  3429.     % Apply the renderer options
  3430.     args {exch cvlit exch def} forall
  3431.        
  3432.     % Parse the user options   
  3433.     opt {
  3434.         token false eq {exit} if dup length string cvs (=) search
  3435.         true eq {cvlit exch pop exch def} {cvlit true def} ifelse
  3436.     } loop
  3437.  
  3438.     /barcolor barcolor cvlit def
  3439.     /textcolor textcolor cvlit def
  3440.     /bordercolor bordercolor cvlit def
  3441.     /backgroundcolor backgroundcolor cvlit def
  3442.     /inkspread inkspread cvr def
  3443.     /width width cvr def
  3444.     /barratio barratio cvr def
  3445.     /spaceratio spaceratio cvr def
  3446.     /borderleft borderleft cvr def
  3447.     /borderright borderright cvr def
  3448.     /bordertop bordertop cvr def
  3449.     /borderbottom borderbottom cvr def
  3450.     /borderwidth borderwidth cvr def
  3451.     /guardleftpos guardleftpos cvr def
  3452.     /guardleftypos guardleftypos cvr def
  3453.     /guardrightpos guardrightpos cvr def
  3454.     /guardrightypos guardrightypos cvr def
  3455.     /guardwidth guardwidth cvr def
  3456.     /guardheight guardheight cvr def
  3457.     
  3458.     % Create bar elements and put them into the bars array
  3459.     /bars sbs length 1 add 2 idiv array def
  3460.     /x 0.00 def /maxh 0 def
  3461.     0 1 sbs length 1 add 2 idiv 2 mul 2 sub {
  3462.         /i exch def
  3463.         i 2 mod 0 eq {           % i is even
  3464.             /d sbs i get barratio mul barratio sub 1 add def  % d=digit*r-r+1 
  3465.             /h bhs i 2 idiv get 72 mul def  % Height from bhs
  3466.             /c d 2 div x add def            % Centre of the bar = x + d/2
  3467.             /y bbs i 2 idiv get 72 mul def  % Baseline from bbs
  3468.             /w d inkspread sub def          % bar width = digit - inkspread
  3469.             bars i 2 idiv [h c y w] put     % Add the bar entry
  3470.             h maxh gt {/maxh h def} if
  3471.         } {
  3472.             /d sbs i get spaceratio mul spaceratio sub 1 add def  % d=digit*r-r+1 
  3473.         } ifelse
  3474.         /x x d add def  % x+=d
  3475.     } for
  3476.  
  3477.     gsave
  3478.  
  3479.     currentpoint translate
  3480.  
  3481.     % Force symbol to given width
  3482.     width 0 ne {
  3483.         width 72 mul x div 1 scale
  3484.     } if
  3485.  
  3486.     % Display the border and background
  3487.     newpath
  3488.     borderleft neg borderbottom neg moveto
  3489.     x borderleft add borderright add 0 rlineto
  3490.     0 maxh borderbottom add bordertop add rlineto
  3491.     x borderleft add borderright add neg 0 rlineto
  3492.     0 maxh borderbottom add bordertop add neg rlineto    
  3493.     closepath
  3494.     backgroundcolor (unset) ne {
  3495.         gsave
  3496.         (<      >) dup 1 backgroundcolor putinterval cvx exec {255 div} forall setrgbcolor
  3497.         fill
  3498.         grestore  
  3499.     } if     
  3500.     showborder {
  3501.         gsave
  3502.         bordercolor (unset) ne {
  3503.             (<      >) dup 1 bordercolor putinterval cvx exec {255 div} forall setrgbcolor
  3504.         } if
  3505.         borderwidth setlinewidth stroke
  3506.         grestore
  3507.     } if    
  3508.    
  3509.     % Display the bars for elements in the bars array
  3510.     gsave
  3511.     barcolor (unset) ne {
  3512.         (<      >) dup 1 barcolor putinterval cvx exec {255 div} forall setrgbcolor
  3513.     } if
  3514.     bars {
  3515.         {} forall
  3516.         newpath setlinewidth moveto 0 exch rlineto stroke
  3517.     } forall
  3518.     grestore
  3519.     
  3520.     % Display the text for elements in the text array
  3521.     textcolor (unset) ne {
  3522.         (<      >) dup 1 textcolor putinterval cvx exec {255 div} forall setrgbcolor
  3523.     } if
  3524.     /s 0 def /f () def
  3525.     txt {
  3526.         {} forall
  3527.         2 copy s ne exch f ne or {
  3528.             2 copy /s exch def /f exch def            
  3529.             exch findfont exch scalefont setfont          
  3530.         } {
  3531.             pop pop
  3532.         } ifelse
  3533.         moveto show
  3534.     } forall
  3535.  
  3536.     % Display the guard elements
  3537.     guardwhitespace {
  3538.         0.75 setlinewidth
  3539.         guardleftpos 0 ne {
  3540.             newpath
  3541.             guardleftpos neg guardwidth add guardleftypos guardwidth 2 div add moveto
  3542.             guardwidth neg guardheight -2 div rlineto
  3543.             guardwidth guardheight -2 div rlineto
  3544.             stroke            
  3545.         } if
  3546.         guardrightpos 0 ne {
  3547.             newpath
  3548.             guardrightpos x add guardwidth sub guardrightypos guardheight 2 div add moveto
  3549.             guardwidth guardheight -2 div rlineto
  3550.             guardwidth neg guardheight -2 div rlineto
  3551.             stroke            
  3552.         } if
  3553.     } if
  3554.     
  3555.     grestore
  3556.     
  3557.     end
  3558.  
  3559. } bind def
  3560. /barcode load 0 1 dict put
  3561. % --END RENDERER--
  3562.  
  3563. % --END TEMPLATE--
  3564.